is_iterable - PHP code example

The Iterable Function in PHP

The is_iterable function in PHP verifies whether a variable is iterable. This helps developers avoid errors caused by trying to loop over non-iterable variables. The is_iterable function takes a variable name as its parameter and returns a boolean value of True or False.

The iterable design pattern is a common approach to traversing complex data structures. It allows clients to go over the elements of the collection in a sequence without exposing the internal details of the collection. It is implemented as an interface that provides navigation methods such as next, previous and current. This is a very useful design pattern that should be used in any application where traversal of the data structure is required.

Besides this, PHP 8.1 introduces named function parameters in addition to positional arguments, adds the ability to define return types to include null as an option and makes it possible for functions to use the SensitiveParameter attribute to mark method parameters that should not be output in an exception stack trace. This could be particularly useful when working with sensitive data such as passwords.

Lastly, the is_iterable() function is an easy-to-use type checker that checks if a variable is iterable. It is very simple to use, and will help avoid runtime errors if an argument that is not iterable is passed to a foreach loop. This is a feature that seems to be very needed in the PHP community, especially for the many plugin and theme developers who write code to support PHP Core and other frameworks.

is_iterable example

$translations = \is_array($translations) ? $translations : iterator_to_array($translations);
        if (isset($translations['DEFAULT'])) {
            $translations[Defaults::LANGUAGE_SYSTEM] = $translations['DEFAULT'];
            unset($translations['DEFAULT']);
        }

        $referenceDefinition = $associationField->getReferenceDefinition();
        $entitySerializer = $this->serializerRegistry->getEntity($referenceDefinition->getEntityName());

        foreach ($translations as $languageId => $translation) {
            $deserialized = $entitySerializer->deserialize($config, $referenceDefinition, $translation);
            if (!\is_array($deserialized) && is_iterable($deserialized)) {
                $deserialized = iterator_to_array($deserialized);
            }

            if (empty($deserialized)) {
                unset($translations[$languageId]);
            } else {
                $translations[$languageId] = $deserialized;
            }
        }

        if (empty($translations)) {

$this->bufferedOutput->write("\n");
        }

        return $answer;
    }

    /** * @return void */
    public function writeln(string|iterable $messages, int $type = self::OUTPUT_NORMAL)
    {
        if (!is_iterable($messages)) {
            $messages = [$messages];
        }

        foreach ($messages as $message) {
            parent::writeln($message, $type);
            $this->writeBuffer($message, true, $type);
        }
    }

    /** * @return void */

foreach ($this->parameters as $name => $value) {
            $headers->setHeaderParameter('Content-Type', $name, $value);
        }

        return $headers;
    }

    public function __sleep(): array
    {
        // convert iterables to strings for serialization         if (is_iterable($this->body)) {
            $this->body = $this->bodyToString();
        }

        $this->_headers = $this->getHeaders();

        return ['_headers', 'body', 'type', 'subtype', 'parameters'];
    }

    public function __wakeup(): void
    {
        $r = new \ReflectionProperty(AbstractPart::class, 'headers');

    public function __construct($name, $value, $attributes = [], $flags = [], $reference_time = null) {
        if (is_string($name) === false) {
            throw InvalidArgument::create(1, '$name', 'string', gettype($name));
        }

        if (is_string($value) === false) {
            throw InvalidArgument::create(2, '$value', 'string', gettype($value));
        }

        if (InputValidator::has_array_access($attributes) === false || InputValidator::is_iterable($attributes) === false) {
            throw InvalidArgument::create(3, '$attributes', 'array|ArrayAccess&Traversable', gettype($attributes));
        }

        if (is_array($flags) === false) {
            throw InvalidArgument::create(4, '$flags', 'array', gettype($flags));
        }

        if ($reference_time !== null && is_int($reference_time) === false) {
            throw InvalidArgument::create(5, '$reference_time', 'integer|null', gettype($reference_time));
        }

private $callback;

    /** * Create a new iterator * * @param array $data The array or object to be iterated on. * @param callable $callback Callback to be called on each value * * @throws \WpOrg\Requests\Exception\InvalidArgument When the passed $data argument is not iterable. */
    public function __construct($data, $callback) {
        if (InputValidator::is_iterable($data) === false) {
            throw InvalidArgument::create(1, '$data', 'iterable', gettype($data));
        }

        parent::__construct($data);

        if (is_callable($callback)) {
            $this->callback = $callback;
        }
    }

    /** * Prevent unserialization of the object for security reasons. * * @phpcs:disable PHPCompatibility.FunctionNameRestrictions.NewMagicMethods.__unserializeFound * * @param array $data Restored array of data originally serialized. * * @return void */

$t = $segment->appendChild($targetElement);
            $t->appendChild($text);

            $xliffFile->appendChild($translation);
        }

        return $dom->saveXML();
    }

    private function hasMetadataArrayInfo(string $key, array $metadata = null): bool
    {
        return is_iterable($metadata[$key] ?? null);
    }
}

$compare = (string) $compare;
    }

    if (\is_string($compare)) {
        if (\is_string($value) || \is_int($value) || \is_float($value)) {
            return '' === $value || false !== strpos($compare, (string) $value);
        }

        return false;
    }

    if (!is_iterable($compare)) {
        return false;
    }

    if (\is_object($value) || \is_resource($value)) {
        if (!\is_array($compare)) {
            foreach ($compare as $item) {
                if ($item === $value) {
                    return true;
                }
            }

if ($field === null) {
                continue;
            }

            $serializer = $this->serializerRegistry->getFieldSerializer($field);
            $value = $serializer->deserialize($config, $field, $value);

            if ($value === null) {
                continue;
            }

            if (is_iterable($value) && !\is_array($value)) {
                $value = iterator_to_array($value);
            }

            // ToOneSerializer may return records with errors             if (\is_array($value) && isset($value['_error']) && $value['_error'] instanceof \Throwable) {
                yield '_error' => $value['_error'];
            }

            yield $key => $value;
        }
    }

    public function writeln(string|iterable $messages, int $options = self::OUTPUT_NORMAL)
    {
        $this->write($messages, true, $options);
    }

    /** * @return void */
    public function write(string|iterable $messages, bool $newline = false, int $options = self::OUTPUT_NORMAL)
    {
        if (!is_iterable($messages)) {
            $messages = [$messages];
        }

        $types = self::OUTPUT_NORMAL | self::OUTPUT_RAW | self::OUTPUT_PLAIN;
        $type = $types & $options ?: self::OUTPUT_NORMAL;

        $verbosities = self::VERBOSITY_QUIET | self::VERBOSITY_NORMAL | self::VERBOSITY_VERBOSE | self::VERBOSITY_VERY_VERBOSE | self::VERBOSITY_DEBUG;
        $verbosity = $verbosities & $options ?: self::VERBOSITY_NORMAL;

        if ($verbosity > $this->getVerbosity()) {
            return;
        }

    public function request_multiple($requests, $options) {
        // If you're not requesting, we can't get any responses ¯\_(ツ)_/¯         if (empty($requests)) {
            return [];
        }

        if (InputValidator::has_array_access($requests) === false || InputValidator::is_iterable($requests) === false) {
            throw InvalidArgument::create(1, '$requests', 'array|ArrayAccess&Traversable', gettype($requests));
        }

        if (is_array($options) === false) {
            throw InvalidArgument::create(2, '$options', 'array', gettype($options));
        }

        $multihandle = curl_multi_init();
        $subrequests = [];
        $subhandles  = [];

public function validate(mixed $vatIds, Constraint $constraint): void
    {
        if (!$constraint instanceof CustomerVatIdentification) {
            throw new UnexpectedTypeException($constraint, CustomerVatIdentification::class);
        }

        if ($vatIds === null) {
            return;
        }

        if (!is_iterable($vatIds)) {
            throw new UnexpectedValueException($vatIds, 'iterable');
        }

        if (!$this->shouldCheckVatIdFormat($constraint)) {
            return;
        }

        if (!$vatPattern = $this->getVatPattern($constraint)) {
            return;
        }

return $normalizer->normalize($data, $format, $context);
        }

        if (null === $data || \is_scalar($data)) {
            return $data;
        }

        if (\is_array($data) && !$data && ($context[self::EMPTY_ARRAY_AS_OBJECT] ?? false)) {
            return new \ArrayObject();
        }

        if (is_iterable($data)) {
            if ($data instanceof \Countable && ($context[AbstractObjectNormalizer::PRESERVE_EMPTY_OBJECTS] ?? false) && !\count($data)) {
                return new \ArrayObject();
            }

            $normalized = [];
            foreach ($data as $key => $val) {
                $normalized[$key] = $this->normalize($val, $format, $context);
            }

            return $normalized;
        }

    public function append(iterable $iterator): static
    {
        if ($iterator instanceof \IteratorAggregate) {
            $this->iterators[] = $iterator->getIterator();
        } elseif ($iterator instanceof \Iterator) {
            $this->iterators[] = $iterator;
        } elseif (is_iterable($iterator)) {
            $it = new \ArrayIterator();
            foreach ($iterator as $file) {
                $file = $file instanceof \SplFileInfo ? $file : new \SplFileInfo($file);
                $it[$file->getPathname()] = $file;
            }
            $this->iterators[] = $it;
        } else {
            throw new \InvalidArgumentException('Finder::append() method wrong argument type.');
        }

        return $this;
    }

    public function __construct(array $defaultContext = [])
    {
        $this->defaultContext = array_merge($this->defaultContext, $defaultContext);
    }

    public function encode(mixed $data, string $format, array $context = []): string
    {
        $handle = fopen('php://temp,', 'w+');

        if (!is_iterable($data)) {
            $data = [[$data]];
        } elseif (empty($data)) {
            $data = [[]];
        } else {
            // Sequential arrays of arrays are considered as collections             $i = 0;
            foreach ($data as $key => $value) {
                if ($i !== $key || !\is_array($value)) {
                    $data = [$data];
                    break;
                }

use Symfony\Component\Translation\Exception\InvalidArgumentException;

/** * Base class used by classes that extract translation messages from files. * * @author Marcos D. Sánchez <marcosdsanchez@gmail.com> */
abstract class AbstractFileExtractor
{
    protected function extractFiles(string|iterable $resource): iterable
    {
        if (is_iterable($resource)) {
            $files = [];
            foreach ($resource as $file) {
                if ($this->canBeExtracted($file)) {
                    $files[] = $this->toSplFileInfo($file);
                }
            }
        } elseif (is_file($resource)) {
            $files = $this->canBeExtracted($resource) ? [$this->toSplFileInfo($resource)] : [];
        } else {
            $files = $this->extractFromDirectory($resource);
        }