When the same authorization check gets copied into twenty resolvers, that's a sign the behavior belongs in the schema declaration instead of repeated code. GraphQL directives make exactly that possible: an @auth tag on a field replaces the boilerplate check, a @formatDate directive controls output formats without touching the resolver.

ITER

→

Deep Dive · Magento 2 Design Patterns

Iterator Pattern:
Collections and Varien_Data_Collection

How Magento's AbstractCollection implements PHP iterators, why lazy loading matters, and how to traverse large catalog data in a memory efficient way.

13 min read

Magento 2.4.8 · PHP 8.4

GoF Behavioral Pattern

Contents

1. 1. GoF Iterator Pattern: the interface
2. 2. PHP Iterator interface and IteratorAggregate
3. 3. Varien_Data_Collection: the foundation
4. 4. Magento AbstractCollection and lazy loading
5. 5. Collection filters, joins and pagination
6. 6. Chunked iterator: large catalogs without memory overflow
7. 7. PHP generators as lazy iterators
8. 8. Building a custom iterator for Magento
9. 9. Iterator vs. getItems(): performance comparison
10. 10. Conclusion: using collections correctly

The Iterator Pattern is one of the most commonly used GoF patterns in Magento, you use it every day whenever you iterate over a collection. foreach ($productCollection as $product) is the Iterator

An assignment like $b = $a for a large PHP array looks at first glance like an expensive copy operation, but internally it initially only costs incrementing a reference counter. Copy-on-Write postpones the actual copy to the moment one of the two variables is actually modified, and this exact mechanism decides memory usage and performance for every array hand off in PHP.

Mocking everything a class touches, indiscriminately, produces unit tests that break on every refactor even though the application's behavior never changed. Gerard Meszaros' taxonomy distinguishes dummy, stub, fake, spy and mock as five clearly separated roles, each with a different purpose, a different verification logic and a different degree of coupling to implementation details. This article walks through the theory behind every test double using hand-written PHP implementations, independent of any particular testing framework.

Duplicated test data in every setUp, magic arrays in DataProviders, and hardcoded IDs scattered across hundreds of test classes. These are the typical signs of a test suite without a clear data organization strategy. The Builder pattern, fixture classes and factory methods bring order without overengineering.

Anyone maintaining several related PHP packages knows the pain: every small change in the core package means a new version, a new tag, and a composer update in every dependent package just to test locally whether everything still fits together. A PHP monorepo with Composer path repositories solves exactly this problem, without making the later release to Packagist any harder.

Anyone hosting several client projects on one server eventually runs into different PHP version requirements, since Magento, WordPress, and legacy applications rarely demand the same version. Versioned FPM packages, update-alternatives, and cleanly separated pools per vhost let you run multiple PHP versions side by side without conflicts and safely in production.

Anyone writing Magento code without tests learns during the first refactoring how fragile the dependencies really are. PHPUnit tests for repositories, service contracts and ViewModels cover the logic of the most important layers, without needing the full Magento bootstrap.

Build-time code generation produces finished, compilable PHP code before an application even starts, instead of reading metadata via reflection again on every request. Symfony and Laravel use this technique for compiled containers, because generated code is treated by OPcache like any regular code and reflection overhead disappears entirely from the hot path.

Swoole Coroutines let PHP handle thousands of concurrent tasks efficiently without spawning threads or extra processes. Once you understand how the cooperative coroutine scheduler works, and how channels and WaitGroup synchronize results, you can use Swoole Coroutines for real concurrency in PHP without inheriting the classic pitfalls of threading.