Some useful traits for PHP 7.2+

3.0.2 2019-03-21 02:32 UTC


A collection of (more or less) useful traits for PHP7.2+

version license Travis Coverage Scrunitizer Packagist downloads PayPal donate


  • ClassLoader - invokes objects of a given class and interface/type with an arbitrary count of constructor arguments
  • Magic - turns methods into magic properties
  • Enumerable - provides some of prototype's enumerable methods, implements EnumerableInterface
  • ArrayHelpers
    • ByteArray - useful for byte/bit-flipping purposes, extends SplFixedArray
    • ByteArrayDispenser - creates ByteArray from several data types (hex, base64, binary, json etc.)
    • DotArray - adds dot key notation functionality
    • SearchableArray - deep search arrays using RecursiveIteratorIterator
  • Interfaces
  • SPL



requires composer

composer.json (note: replace dev-master with a version boundary)

	"require": {
		"php": "^7.2",
		"chillerlan/php-traits": "dev-master"

Manual installation

Download the desired version of the package from master or release and extract the contents to your project folder. After that:

  • run composer install to install the required dependencies and generate /vendor/autoload.php.
  • if you use a custom autoloader, point the namespace chillerlan\Traits to the folder src of the package




Simple usage:

class MyClass{
	use ClassLoader;
	protected function doStuff(string $class){
		$obj = $this->loadClass(__NAMESPACE__.'\\Whatever\\'.$class);
		// do stuff

Let's assume we have several classes that implement the same interface, but their constructors have different parameter counts, like so:

class SomeClass implements MyInterface{
	public funtion __construct($param_foo){}

class OtherClass implements MyInterface{
	public funtion __construct($param_foo, $param_bar){}

Initialize an object based on a selction

class MyClass{
	use ClassLoader;
	protected $classes = [
		'foo' => SomeClass::class, 
		'bar' => OtherClass::class
	protected funtion initInterface(string $whatever, $foo, $bar = null):MyInterface{
		foreach($this->classes as $what => $class){
			if($whatever === $what){
				return $this->loadClass($class, MyInterface::class, $foo, $bar);


Magic allows to access internal methods like as properties.

class MyMagicContainer{
	use Magic;

	protected $foo;

	protected function magic_get_foo(){
		// do whatever...
		return 'foo: '.$this->foo;

	protected function magic_set_foo($value){
		// do stuff with $value
		// ...
		$this->foo = $value.'bar';
$magic = new MyMagicContainer;

$magic->foo = 'foo';

var_dump($magic->foo); // -> foo: foobar


class MyEnumerableContainer implements EnumerableInterface{
	use Enumerable;

	public function __construct(array $data){
		$this->array = $data;
$enum = new MyEnumerableContainer($data);

	->__each(function($value, $index){
		// do stuff
		$this->array[$index] = $stuff;

$arr = $enum->__map(function($value, $index){
	// do stuff
	return $stuff;