PHPackages                             lordmonoxide/phi - 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. [Utility & Helpers](/categories/utility)
4. /
5. lordmonoxide/phi

ActiveLibrary[Utility & Helpers](/categories/utility)

lordmonoxide/phi
================

A super-minimal inversion-of-control library

1.2.0(11y ago)37811GPLv3PHPPHP >=5.4.0

Since May 8Pushed 10y ago1 watchersCompare

[ Source](https://github.com/LordMonoxide/phi)[ Packagist](https://packagist.org/packages/lordmonoxide/phi)[ Docs](http://github.com/LordMonoxide/phi)[ RSS](/packages/lordmonoxide-phi/feed)WikiDiscussions master Synced 1mo ago

READMEChangelog (3)Dependencies (1)Versions (4)Used By (1)

This package has been superceded by [BapCat/Phi](https://github.com/BapCat/Phi/).
=================================================================================

[](#this-package-has-been-superceded-by-bapcatphi)

[![Build Status](https://camo.githubusercontent.com/8d1448889642bdac7bff61de985111cc3dd136ccfd19542a5b78c7ecd525482a/68747470733a2f2f7472617669732d63692e6f72672f4c6f72644d6f6e6f786964652f7068692e7376673f6272616e63683d312e322e30)](https://travis-ci.org/LordMonoxide/phi)[![Coverage Status](https://camo.githubusercontent.com/9ad5aa8d74027c492441d28d1befdf8fec04d3ea6dda3189f6d46e46f6791a40/68747470733a2f2f636f766572616c6c732e696f2f7265706f732f4c6f72644d6f6e6f786964652f7068692f62616467652e7376673f6272616e63683d312e322e30)](https://coveralls.io/r/LordMonoxide/phi?branch=1.2.0)[![License](https://camo.githubusercontent.com/a633ae7b80c0a3a6b83ea3818cdcc55b4e67fdd6496b94c3415486c47cf8855f/68747470733a2f2f696d672e736869656c64732e696f2f7061636b61676973742f6c2f4c6f72644d6f6e6f786964652f7068692e737667)](https://img.shields.io/packagist/l/LordMonoxide/phi.svg)

φhi
===

[](#φhi)

An efficient, easy-to-use, open-source PHP dependency injection container, boasting a tiny footprint, powerful features, 100% unit test coverage, and awesome documentation. Phi is compatible with PSR-0 and PSR-4 auto-loading standards, and open to collaboration from anyone who feels they can make an improvement.

Installation
------------

[](#installation)

### Composer

[](#composer)

[Composer](https://getcomposer.org/) is the recommended method of installation for Phi.

```
$ composer require lordmonoxide/phi

```

### GitHub

[](#github)

Phi may be downloaded from [GitHub](https://github.com/LordMonoxide/phi/).

Features
--------

[](#features)

Phi supports several different ways to inject dependencies, which can all be used alone or in conjunction with one another.

### Automatic Injection

[](#automatic-injection)

Assume you have a class named `Foo` that depends on a second class, `Bar`:

```
class Foo {
  public $bar = null;

  public function __construct(Bar $bar) {
    $this->bar = $bar;
  }
}
```

You can easily get a new instance of `Foo` with all required dependencies by doing the following:

```
$foo = $phi->make('Foo');
// $foo->bar = new Bar
```

You'll get a new instance of `Foo` with a new instance of `Bar` automatically injected into the constructor. This, of course, works recursively. If `Bar` depends on `Baz`, an instance of `Baz` will be injected into `Bar`, and so on.

### Passing Parameters

[](#passing-parameters)

There will be many cases where you need to pass parameters into the constructors as well. Consider the following class (note the order of the parameters):

```
class Foo {
  public $a = null;
  public $b = null;
  public $first_name = null;
  public $last_name  = null;

  public function __construct(B $b, A $a, $first_name = null, $last_name = null) {
    $this->a = $a;
    $this->b = $b;
    $this->first_name = $first_name;
    $this->last_name  = $last_name;
  }
}
```

There are several ways you can request this class from Phi:

```
$foo = $phi->make('Foo');
// $foo->a == new A
// $foo->b == new B
// $foo->first_name == null
// $foo->last_name  == null
```

```
$foo = $phi->make('Foo', ['John', 'Doe']);
// $foo->a == new A
// $foo->b == new B
// $foo->first_name == 'John'
// $foo->last_name  == 'Doe'
```

```
$foo = $phi->make('Foo', ['John']);
// $foo->a == new A
// $foo->b == new B
// $foo->first_name == 'John'
// $foo->last_name  == null
```

You may want to override an automatically injected parameter:

```
$a = new A;
$foo = $phi->make('Foo', ['John', 'Doe', $a]);
// $foo->a == $a
// $foo->b == new B
// $foo->first_name == 'John'
// $foo->last_name  == 'Doe'
```

Note that `$a` was passed in last in the previous example. Phi is smart enough to figure out the correct order to inject parameters of non-scalar types.

### Multiple Same-Type Dependencies

[](#multiple-same-type-dependencies)

Consider the following class:

```
class Foo {
  public function __construct(BarInterface $bar, A $a, BarInterface $baz, B $b) {
    // ...
  }
}
```

```
$bar = new Bar; // implements BarInterface
$baz = new Baz; // implements BarInterface
$foo = $phi->make('Foo', [$bar, $baz]);
// $foo->bar == $bar
// $foo->baz == $baz
// $foo->a   == new A
// $foo->b   == new B
```

Parameters of the same type will be passed to the constructor in the order they are given to Phi. If you would like to pass them in a different order, please see the section on [named injection](https://github.com/LordMonoxide/phi#named-injection).

### Named Injection

[](#named-injection)

In some cases, it is useful to be explicit about which parameters you are passing in. Phi makes this easy. Consider the class from the "Passing Parameters" section:

```
class Foo {
  public function __construct(A $a, B $b, $first_name = null, $last_name = null) {
    // ...
  }
}
```

```
$a = new A;
$b = new B;
$foo = $phi->make('Foo', [$b, 'last_name' => 'Doe', $a]);
// $foo->a == $a
// $foo->b == $b
// $foo->first_name == null
// $foo->last_name  == 'Doe'
```

### Binding

[](#binding)

Many modern applications have pieces that may be swapped out. This is accomplished by using interfaces. Phi allows automatic injection of interfaces using binding:

```
interface BarInterface {

}

class Bar implements BarInterface {

}

class Foo {
  public function __construct(BarInterface $bar) {
    // ...
  }
}

$phi->bind('BarInterface', 'Bar');
```

```
$foo = $phi->make('Foo');
// $foo->bar == new Bar
```

```
$bar = $phi->make('BarInterface');
// $bar = new Bar
```

Binding even allows you to swap one concrete instance of a class for another:

```
$phi->bind('A', 'B');

$a = $phi->make('A');
// $a == new B
```

### Dependencies With Parameters

[](#dependencies-with-parameters)

Sometimes you may have a dependency that has required parameters. This can be done by binding a class to a callable:

```
$phi->bind('Person', function() {
  return new Person('John', 'Doe');
});

$person = $phi->make('Person');
// $person->first_name == 'John'
// $person->last_name  == 'Doe'
```

This is also useful if you need to perform logic when instanciating a class:

```
$id = 0;

$phi->bind('Person', function() use(&$id) {
  return new Person(++$id);
});

$person1 = $phi->make('Person'); // id == 1
$person2 = $phi->make('Person'); // id == 2
```

Any parameters passed to Phi will be passed directly to the callable:

```
$id = 0;

$phi->bind('Person', function($name, $age) use(&$id) {
  $names = explode(' ', $name);
  return new Person(++$id, $name[0], $name[1], $age);
});

$person = $phi->make('Person', ['John Doe', 21]);
// $person->id == 1
// $person->first_name == 'John'
// $person->last_name  == 'Doe'
// $person->age == 21
```

### Singletons

[](#singletons)

Phi also allows binding to real instances of classes. This can be used to create singletons:

```
$default_pdo = new PDO(...); // The default database
$stats_pdo   = new PDO(...); // PDO pointing to a different database

$phi->bind('PDO', $default_pdo);
```

```
$pdo = $phi->make('PDO');
// $pdo == $default_pdo
```

```
class Table {
  public function __construct(PDO $pdo, $table_name) {
    // ...
  }
}

$users_table = $phi->make('Table', ['users']);
// $users_table->pdo   == $default_pdo
// $users_table->table == 'users'

$stats_table = $phi->make('Table', [$stats_pdo, 'stats']);
// $stats_table->pdo   == $stats_pdo
// $stats_table->table == 'stats'
```

### Aliases

[](#aliases)

Sometimes, a codebase will have very commonly used classes with difficult-to remember names. For example, `Vendor\Package\Core\Logging\Log`. It may be useful to give such classes shorter and easier to type names:

```
$phi->bind('core.log', 'Vendor\Package\Core\Logging\Log');

$log = $phi->make('core.log');
// $log == new Vendor\Package\Core\Logging\Log
```

You may also bind aliases to callables or singletons.

### Custom Resolvers

[](#custom-resolvers)

There may be times when you want to match far more than a single alias. Custom resolvers were designed with this purpose in mind. When a binding is requested from Phi, any custom resolvers that are registered will be executed one by one in the order they were added, and the first one to return a non-null value is the one that will be used. If all custom resolvers return null, Phi will resolve the binding normally.

```
use LordMonoxide\Phi\ResolverInterface;

class CustomResolver implements ResolverInterface {
  public function make($alias, array $arguments = []) {
    if($alias == 'A') {
      return new B(new A());
    }
  }
}

$phi->addResolver(new CustomResolver());
```

```
$b = $phi->make('A');
//$b == new B
```

Another reason to use custom resolvers is to wrap other IoC containers. For example, if you are using Laravel, you could combine the Laravel container with Phi:

```
use Illuminate\Support\Facades\App;
use LordMonoxide\Phi\ResolverInterface;

class LaravelResolver implements ResolverInterface {
  public function make($alias, array $arguments = []) {
    if(App::bound($alias)) {
      return App::make($alias, $arguments);
    }
  }
}

$phi->addResolver(new LaravelResolver());
```

This way, any binding that is registered in the Laravel IoC container will be resolved by it. The rest will be passed on to Phi.

###  Health Score

28

—

LowBetter than 54% of packages

Maintenance20

Infrequent updates — may be unmaintained

Popularity13

Limited adoption so far

Community10

Small or concentrated contributor base

Maturity60

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

Total

3

Last Release

4023d ago

### Community

Maintainers

![](https://www.gravatar.com/avatar/246ea082e8ed7f6e8ace29950179d4dfb1e3a58bac53aef49a3d2e43ab1e7f04?d=identicon)[LordMonoxide](/maintainers/LordMonoxide)

---

Top Contributors

[![LordMonoxide](https://avatars.githubusercontent.com/u/437657?v=4)](https://github.com/LordMonoxide "LordMonoxide (43 commits)")

---

Tags

dependency-injectiondiiocinversion of control

### Embed Badge

![Health badge](/badges/lordmonoxide-phi/health.svg)

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

###  Alternatives

[level-2/dice

A minimalist Dependency injection container (DIC) for PHP. Please note: 3.0+ is only compatible with PHP 7.0. The 2.0 branch is compatbile with PHP 5.6.

437730.3k17](/packages/level-2-dice)[mouf/mouf

The Mouf PHP framework: an open-source PHP framework providing an easy way to download, install, use and reuse components, with a graphical user interface.

55146.0k17](/packages/mouf-mouf)[capsule/di

A PSR-11 compliant autowiring dependency injection container.

2857.5k2](/packages/capsule-di)[x-wp/di

The dependency injection container for WordPress

301.1k10](/packages/x-wp-di)[michaels/data-manager

Simple data manager for nested data, dot notation array access, extendability, and container interoperability.

121.9k2](/packages/michaels-data-manager)

PHPackages © 2026

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