PHPackages                             netherphp/cache - 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. netherphp/cache

ActiveLibrary[Caching](/categories/caching)

netherphp/cache
===============

A cache interface.

v3.0.5(4y ago)0383[1 PRs](https://github.com/netherphp/cache/pulls)1BSD-2-ClausePHPPHP >=8.0.0CI failing

Since May 19Pushed 3mo agoCompare

[ Source](https://github.com/netherphp/cache)[ Packagist](https://packagist.org/packages/netherphp/cache)[ RSS](/packages/netherphp-cache/feed)WikiDiscussions master Synced 4d ago

READMEChangelogDependencies (2)Versions (16)Used By (1)

Nether Cache
============

[](#nether-cache)

Lightweight management of cache storage and retrieval.

- `LocalEngine` - caches data in local memory while the app is running.
- `MemcacheEngine` - accesses memcached network cache.
- `FilesystemEngine` - cache data as files.

Additional cache engines can be implemented with `EngineInterface`.

Licenced under BSD-2-Clause-Patent. See LICENSE for details.

Usage
=====

[](#usage)

Low Level
---------

[](#low-level)

Create a cache manager and throw cache engines into it. If no priority value is set then the priorities will be set such that the caches will always be checked FIFO. In this example case the LocalEngine will always be checked before the MemcacheEngine which will aways be checked before the FilesystemEngine. The priorties can be used to stack caches from fastest to slowest.

```
$Manager = new Nether\Cache\Manager;

$Manager
->EngineAdd(new Nether\Cache\Engines\LocalEngine)
->EngineAdd(new Nether\Cache\Engines\MemcacheEngine(
	Servers: [ 'localhost:11211' ]
))
->EngineAdd(new Nether\Cache\Engines\FilesystemEngine(
	Path: '/where/ever'
));
```

Throw data into the caches, ask about it, and get it back out.

```
$Manager->Set('unique-id','value');

var_dump(
	$Manager->Has('unique-id'),
	$Manager->Get('unique-id')
);

// bool(true)
// string(5) "value"
```

Delete data from the caches.

```
$Manager->Drop('unique-id');

var_dump(
	$Manager->Has('unique-id'),
	$Manager->Get('unique-id')
);

// bool(false)
// NULL
```

Debugging
---------

[](#debugging)

The contents of the cache are wrapped with a small descriptor object that describes the data, and can be inspected by getting a cache object rather than the cache data directly.

- `CacheObject->Time` is the unix timestamp the data was added to the cache.
- `CacheObject->Engine` will be the the cache engine instance that the data was found in.
- `CacheObject->Origin` will be NULL unless it is defined when data is set. It is meant to be meta to trace what part of a project pushed the data into the cache.

```
$Manager->Set('test', 'geordi', Origin:'engineering');
print_r($Manager->GetCacheObject('unique-id'));
```

```
Nether\Cache\Struct\CacheObject Object
(
	[Data]   => geordi
	[Time]   => 1622487745
	[Origin] => engineering
	[Engine] => Nether\Cache\Engines\LocalEngine Object
		(
			[...]
		)
)

```

LocalEngine
===========

[](#localengine)

```
new Nether\Cache\Engines\LocalEngine(
	UseGlobal: bool
);
```

Setting UseGlobal to TRUE will allow multiple instances to access the same dataset. This would allow creation of instances when needed rather than early in an app and stored as a singleton somewhere.

The way this engine works is literally it is just an array that is local to this currently running application. Why ask Memcached for the same thing twice if we could remember it the first time?

MemcacheEngine
==============

[](#memcacheengine)

```
new Nether\Cache\Engines\MemcacheEngine(
	UseGlobal: bool,
	Memcache: Memcache|null
);
```

Setting UseGlobal to TRUE will allow multiple instances to access the same defined server pool. This would allow creation of instances when needed rather than early in an app and stored as a singleton somewhere.

Providing a Memcache instance will use whatever pool that instance was built with. Additionally, this allows dependency injection of a mock for testing.

`Engine->ServerAdd(string Host, int Port=11211)`

Add servers to the Memcache pool.

FilesystemEngine
================

[](#filesystemengine)

```
new Nether\Cache\Engines\FilesystemEngine(
	Path: string,
	UseHashType: string|NULL,
	UseHashStruct: bool
	UseFullDrop: bool
);
```

Path is the only required argument, that being the path to the directory where cache data should be stored.

By default the filesystem engine works just like the others. Store data under the key "test" and get a file called "test" in the directory the engine is pointing at. There are additional features though to help make the filesystem engine more robust at larger scales.

`Engine->UseHashType(?string HashAlgoName)`

Given any hash name supported by your system instead of storing the cache file as a literal file called "test" it will be called whatever it hashes out to be. Setting it to NULL will disable the hashing.

`Engine->UseHashStruct(bool Should)`

If TRUE the engine will mess around with the final filename a bit to help avoid hitting filesystem limits for maximum files in a directory. Given a filename hash worked out to `abcdef` it will be transformed to be `ab/cdef` to help distribute the cache files across many directories. As of the time of this writing, this is the same as how Git stores its object files in the .git folders.

###  Health Score

41

—

FairBetter than 89% of packages

Maintenance53

Moderate activity, may be stable

Popularity12

Limited adoption so far

Community8

Small or concentrated contributor base

Maturity76

Established project with proven stability

 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 ~184 days

Recently: every ~1 days

Total

13

Last Release

1802d ago

Major Versions

v1.1.0 → v2.0.02016-02-26

v2.0.5 → v3.0.02021-06-02

PHP version history (3 changes)v1.0.0PHP >=5.4.0

v2.0.0PHP >=7.0.0

v3.0.0PHP >=8.0.0

### Community

Maintainers

![](https://www.gravatar.com/avatar/b64ee49e86efa67a7de4afdc42c2686460d1e46ac7eac7e6ccfa6407ec7d979a?d=identicon)[bobmagicii](/maintainers/bobmagicii)

---

Top Contributors

[![bobmagicii](https://avatars.githubusercontent.com/u/881944?v=4)](https://github.com/bobmagicii "bobmagicii (54 commits)")

---

Tags

phpcachenether

###  Code Quality

TestsPHPUnit

### Embed Badge

![Health badge](/badges/netherphp-cache/health.svg)

```
[![Health](https://phpackages.com/badges/netherphp-cache/health.svg)](https://phpackages.com/packages/netherphp-cache)
```

###  Alternatives

[awssat/laravel-visits

Laravel Redis visits counter for Eloquent models

975163.6k2](/packages/awssat-laravel-visits)[swayok/alternative-laravel-cache

Replacements for Laravel's redis and file cache stores that properly implement tagging idea. Powered by cache pool implementations provided by http://www.php-cache.com/

202541.1k6](/packages/swayok-alternative-laravel-cache)[eftec/cacheone

A Cache library with minimum dependency

103.5k4](/packages/eftec-cacheone)

PHPackages © 2026

[Directory](/)[Categories](/categories)[Trending](/trending)[Changelog](/changelog)[Analyze](/analyze)