PHPackages tomloprod/memoize - PHPackages - PHPackages [Skip to content](#main-content)[PHPackages](/)[Directory](/)[Categories](/categories)[Trending](/trending)[Leaderboard](/leaderboard)[Changelog](/changelog)[Analyze](/analyze)[Collections](/collections)[Log in](/login)[Sign up](/register) 1. [Directory](/) 2. / 3. [Caching](/categories/caching) 4. / 5. tomloprod/memoize ActiveLibrary[Caching](/categories/caching) tomloprod/memoize ================= Memoize is a lightweight PHP library designed to handle memoization with ease. v2.3.0(6mo ago)412.2k↓40.5%2MITPHPPHP ^8.2.0CI passing Since Jul 25Pushed 6mo agoCompare [ Source](https://github.com/tomloprod/memoize)[ Packagist](https://packagist.org/packages/tomloprod/memoize)[ Fund](https://www.paypal.com/paypalme/tomloprod)[ RSS](/packages/tomloprod-memoize/feed)WikiDiscussions main Synced 1mo ago READMEChangelog (5)Dependencies (4)Versions (6)Used By (0) 🧠 Memoize - PHP Memoization Library =================================== [](#-memoize---php-memoization-library) **High-performance memoization and function caching library for PHP** [![GitHub Workflow Status (master)](https://github.com/tomloprod/memoize/actions/workflows/tests.yml/badge.svg)](https://github.com/tomloprod/memoize/actions) [![Total Downloads](https://camo.githubusercontent.com/95b573d3bd10287f5076676e65f11412d796c8ed7d0683479ea0dc33a4b25a7f/68747470733a2f2f696d672e736869656c64732e696f2f7061636b61676973742f64742f746f6d6c6f70726f642f6d656d6f697a65)](https://packagist.org/packages/tomloprod/memoize) [![Latest Version](https://camo.githubusercontent.com/7bb1e4e8ba003ada53f8f5d01ecab66a809a6f7f1848b1fbc5e3ff7a1006aae9/68747470733a2f2f696d672e736869656c64732e696f2f7061636b61676973742f762f746f6d6c6f70726f642f6d656d6f697a65)](https://packagist.org/packages/tomloprod/memoize) [![License](https://camo.githubusercontent.com/98879c55def50cc8d3e578135c319831c61275f44dfdf1d7ba3e32e81e2a3040/68747470733a2f2f696d672e736869656c64732e696f2f7061636b61676973742f6c2f746f6d6c6f70726f642f6d656d6f697a65)](https://packagist.org/packages/tomloprod/memoize) --- 🎯 **About Memoize** ------------------- [](#-about-memoize) **Memoize** is a lightweight PHP library designed to implement memoization and function caching techniques with ease. Transform expensive function calls into lightning-fast cache lookups with zero configuration. ✨ **Features** -------------- [](#-features) πŸ”‘ **Key-based Memoization** Cache function results with custom keys ⚑ **Single Execution** Functions run only once, results cached forever 🏷️ **Namespaces** Organize cache by classes or contexts 🧠 **LRU Cache** Automatic memory management with size limits πŸ“Š **Cache Analytics** Built-in statistics and monitoring πŸƒ **Runtime Flags** Dynamic behavior control during execution πŸ”„ **Enable/Disable** Temporarily disable memoization when needed πŸš€ **Quick Start - PHP Memoization** ----------------------------------- [](#-quick-start---php-memoization) ### Installation [](#installation) ``` composer require tomloprod/memoize ``` ### Basic Usage [](#basic-usage) #### 🏷️ **Namespace Organization** [](#️-namespace-organization) If you want to get the most out of the package and better organize your memoization, we recommend using namespaces. When using namespaces, if you use a `$key` with a null value, the callback won’t be executed (*especially useful in certain cases*). ``` // Organize cache by context $userSettings = memoize() ->for(UserSettings::class) ->memo($userId, fn() => UserSettings::where('user_id', $userId)->first()); $productCache = memoize() ->for(Product::class) ->memo($productId, fn() => Product::with('variants')->find($productId)); ``` #### πŸ”‘ **Key-based Memoization** [](#-key-based-memoization) You can also not use namespaces and just memoize keys. ``` // Expensive API call cached by key $weather = memoize()->memo( 'weather_london', fn() => Http::get('api.weather.com/london')->json() ); // Database query with dynamic key $user = memoize()->memo( "user_{$id}", fn() => User::with('profile', 'orders')->find($id) ); ``` #### ⚑ **Single Execution Functions** [](#-single-execution-functions) ``` // Initialize expensive resources only once $services = memoize()->once(fn() => [ 'redis' => new Redis(), 'elasticsearch' => new Client(), 'logger' => new Logger(), ]); $redis = $services()['redis']; // Initialized once $same = $services()['redis']; // Same instance ``` #### 🧠 **Memory Management** [](#-memory-management) The library uses an **LRU (Least Recently Used)** algorithm to automatically manage memory and prevent unlimited cache growth. **How does LRU work?** - Maintains a record of the access order for cache entries - When the maximum limit (`maxSize`) is reached, automatically removes the **least recently used** entry - Every time you access an entry (read or write), it moves to the front of the queue - Older entries remain at the end and are candidates for removal This ensures that the most relevant and frequently used data remains in memory, while obsolete data is automatically removed. ``` // Set LRU cache limit (by default, there is no max size) memoize()->setMaxSize(1000); // Cache statistics $stats = memoize()->getStats(); // ['size' => 150, 'maxSize' => 1000, 'head' => [...], 'tail' => [...]] // Clear specific or all cache memoize()->forget('user_123'); memoize()->for('App\\Model\\User')->forget('123'); // Or clear all cache memoize()->flush(); ``` #### πŸ”„ **Enable/Disable Memoization** [](#-enabledisable-memoization) You can temporarily disable memoization to bypass caching when needed. When disabled, callbacks are executed every time without storing results in cache. ``` // Disable memoization memoize()->disable(); // Now all memo() calls will execute callbacks without caching $result1 = memoize()->memo('key', fn() => expensiveOperation()); // Executes $result2 = memoize()->memo('key', fn() => expensiveOperation()); // Executes again // Re-enable memoization memoize()->enable(); // Now caching works normally again $result3 = memoize()->memo('key', fn() => expensiveOperation()); // Executes and caches $result4 = memoize()->memo('key', fn() => expensiveOperation()); // Returns cached value // Check current state if (memoize()->isEnabled()) { // Memoization is active } ``` **Use cases:** - Debugging: Temporarily disable caching to see fresh data - Testing: Ensure callbacks execute every time during tests - Conditional behavior: Disable caching based on environment or conditions #### πŸƒ **Runtime Flags** [](#-runtime-flags) Control memoization behavior dynamically during execution with runtime flags. These flags exist only in memory and reset between requests/processes. **How do runtime flags work?** - Flags are stored in memory during the current execution - They allow conditional behavior without external configuration - Perfect for debug modes, logging control, and dynamic optimizations - Automatically cleared when the process ends ``` // Skip cache during testing memoize()->enableFlag('bypass_cache'); $userData = memoize()->memo("user_{$id}", function() use ($id) { if (memoize()->hasFlag('bypass_cache')) { return User::fresh()->find($id); // Always fetch from DB in tests } return User::find($id); }); // Feature toggles without external dependencies memoize()->enableFlag('new_algorithm'); $result = memoize()->memo($cacheKey, function() { if (memoize()->hasFlag('new_algorithm')) { return $this->calculateWithNewAlgorithm(); } return $this->calculateWithOldAlgorithm(); }); // Development vs Production behavior if (app()->environment('local') && memoize()->hasFlag('dev_mode')) { memoize()->enableFlags(['verbose_logging', 'bypass_cache']); } // Model boot method with conditional service calls class Product extends Model { protected static function boot() { parent::boot(); static::updated(function ($product) { // Only call external stock service if flag is not set if (! memoize()->hasFlag('disableStockService')) { app(StockService::class)->updateInventory($product); } }); } } ``` **Runtime Flag Methods:** **Method****Description****enableFlag(string $flag)** Enable a specific runtime flag**disableFlag(string $flag)** Disable a specific runtime flag**toggleFlag(string $flag)** Toggle flag state (enabled/disabled)**hasFlag(string $flag): bool** Check if a specific flag is enabled**enableFlags(array $flags)** Enable multiple flags at once**disableFlags(array $flags)** Disable multiple flags at once**hasAnyFlag(array $flags): bool** Check if at least one flag is enabled**hasAllFlags(array $flags): bool** Check if all specified flags are enabled**getFlags(): array** Get all currently enabled flags**clearFlags()** Clear all enabled flagsπŸ’‘ **Advanced Examples** ----------------------- [](#-advanced-examples) ### πŸƒβ€β™‚οΈ **Performance Optimization** [](#‍️-performance-optimization) ``` // Fibonacci with memoization - O(n) instead of O(2^n) function fibonacci(int $n): int { return memoize()->memo( "fib_{$n}", fn() => $n memo( "sales_report_{$month}", fn() => Order::whereMonth('created_at', $month) ->with('items.product') ->get() ->groupBy('status') ->map(fn($orders) => $orders->sum('total')) ); ``` πŸ“– **API Reference** ------------------- [](#-api-reference) ### Core Methods [](#core-methods) **Method****Description****memo(string|int|float|null $key, callable $callback)** **Key-based memoization** - Execute callback and cache result by key. Returns cached value on subsequent calls. **once(callable $callback)** **Single execution** - Returns a wrapper function that executes the callback only once, caching the result forever. **for(string $class)** **Namespace organization** - Set namespace to organize cache by class/context. Automatically cleared after use. ### Cache Management [](#cache-management) **Method****Description****has(string|int|float $key): bool** Check if a key exists in cache**forget(string|int|float $key): bool** Remove specific key from cache**flush(): void** Clear all cached values**setMaxSize(?int $maxSize): void** Set maximum entries (LRU eviction)**getStats(): array** Get detailed cache statistics**disable(): void** Disable memoization (callbacks execute without caching)**enable(): void** Enable memoization (default state)**isEnabled(): bool** Check if memoization is currently enabledβš™οΈ **Requirements & Installation** -------------------------------------- [](#️-requirements--installation) - **PHP 8.2+** - **Composer** ``` composer require tomloprod/memoize ``` **πŸ§‘β€πŸ€β€πŸ§‘ Contributing** ---------------------- [](#‍‍-contributing) Contributions are welcome, and are accepted via pull requests. Please [review these guidelines](./CONTRIBUTING.md) before submitting any pull requests. --- **Memoize** was created by **[TomΓ‘s LΓ³pez](https://twitter.com/tomloprod)** and open-sourced under the **[MIT license](https://opensource.org/licenses/MIT)**. ### Health Score 43 β€” FairBetter than 91% of packages Maintenance67 Regular maintenance activity Popularity32 Limited adoption so far Community7 Small or concentrated contributor base Maturity52 Maturing project, gaining track record Bus Factor1 Top contributor holds 100% of commits β€” single point of failure How is this calculated?**Maintenance (25%)** β€” Last commit recency, latest release date, and issue-to-star ratio. Uses a 2-year decay window. **Popularity (30%)** β€” Total and monthly downloads, GitHub stars, and forks. Logarithmic scaling prevents top-heavy scores. **Community (15%)** β€” Contributors, dependents, forks, watchers, and maintainers. Measures real ecosystem engagement. **Maturity (30%)** β€” Project age, version count, PHP version support, and release stability. ### Release Activity Cadence Every ~26 days Total 5 Last Release 191d ago Major Versions v1.0.0 β†’ v2.0.02025-09-21 ### Community Maintainers ![](https://www.gravatar.com/avatar/1c9df012919bdcf3f17fad0e3a84ec77641f1f9671f85cb9c4377242ba09dde8?d=identicon)[tomloprod](/maintainers/tomloprod) --- Top Contributors [![tomloprod](https://avatars.githubusercontent.com/u/7898894?v=4)](https://github.com/tomloprod "tomloprod (12 commits)") --- Tags cacheflagsfluent-apimemoizeperformance-optimizationphputilitymemoization ### Code Quality TestsPest Static AnalysisRector Code StyleLaravel Pint ### Embed Badge ![Health badge](/badges/tomloprod-memoize/health.svg) ``` [![Health](https://phpackages.com/badges/tomloprod-memoize/health.svg)](https://phpackages.com/packages/tomloprod-memoize) ``` ### Alternatives [spatie/once A magic memoization function 1.4k29.1M79](/packages/spatie-once)[react/cache Async, Promise-based cache interface for ReactPHP 444112.4M40](/packages/react-cache)[wp-media/wp-rocket Performance optimization plugin for WordPress 7431.3M3](/packages/wp-media-wp-rocket)[illuminate/cache The Illuminate Cache package. 12835.6M1.4k](/packages/illuminate-cache)[colinmollenhour/php-redis-session-abstract A Redis-based session handler with optimistic locking 6325.6M14](/packages/colinmollenhour-php-redis-session-abstract)[cheprasov/php-redis-client Php client for Redis. It is a fast, fully-functional and user-friendly client for Redis, optimized for performance. RedisClient supports the latest versions of Redis starting from 2.6 to 6.0 1281.2M21](/packages/cheprasov-php-redis-client) PHPackages Β© 2026 [Directory](/)[Categories](/categories)[Trending](/trending)[Changelog](/changelog)[Analyze](/analyze)