How can I conditionally make a class use a trait if it exists?

Question

I want to be able to use the trait if it's available.

Obviously i cannont define that inside the class itself (syntax Error)

//fails
include_once('myTrait.php');

class foo
{ 
    var $bar; 

    if (trait_exists('myTrait')) {
        use myTrait;
    }
}

//also fails
foo use myTrait;

//also fails
$f = new foo();
$f use myTrait;

//also fails
$f = new foo() use myTrait;

Ideal case scenario would be something like this:

class foo
{
    var $bar;
}

if (file_exists('myTrait.php')) {
   include_once('myTrait.php');
   //make class foo use myTrait;
}

$f=new foo();

Having hard time finding documentation and traits doesn't seems very popular but in my particular case they are very useful. I also try to keep resource as low a possible by only including files if needed.

Hints, documentation and explanation welcome as usual.

---

The closest my search brought me was in this article http://brendan-bates.com/traits-the-right-way/

Let's say a few of these controllers (but not all of them) require a database connection. To keep performance up, we shouldn't give every controller the database connection. What we could do is write an abstract class which extends BaseController which provides a database connection. But, in the future, what if an object that is not a controller requires a database connection? Instead of duplicating this logic, we can use horizontal reuse.

A simple trait can be created:

trait DatabaseAware 
{    
    protected $db;

    public function setDatabase($db) 
    {
        $this->db = $db;
    }

    protected function query($query) 
    {
        $this->db->query($query);
    }
}

This trait now provides classes with common database functionality. Any class which requires a database connection, be it a controller or a manager (or anything), can use this trait:

class IndexController extends BaseController 
{
    use DatabaseAware;

    public function indexAction() 
    {
        $this->query("SELECT * FROM `someTable`");
    }
}

Where as I implement traits depending on the needs of my different objects. Database connection, debugging reporting, etc.

Answer 1

Easy!

Trait

A trait that might be available or not, will be either used or not, but will eventually help to implement an interface:

<?php

trait BarTrait
{
    public function bar()
    {
        return 'Hey, I am your friend!';
    }
}

Interface

An interface we are looking to implement:

<?php

interface BarInterface
{
    /**
     * @return string
     */
    public function bar();
}

Class using trait

A class FooUsingBarTrait which uses a trait BarTrait to implement the aforementioned interface:

<?php

class FooUsingBarTrait implements BarInterface
{
    use BarTrait;
}

Class not using trait

A class FooNotUsingBarTrait which does not use a trait BarTrait, but instead implements the aforementioned interface itself:

class FooNotUsingBarTrait implements BarInterface
{
    public function bar()
    {
        return 'Hey, I am one of your friends!';
    }
}

Conditionally create class definition

Finally, conditionally define a class Foo, depending on whether a trait BarTrait exists or not:

<?php

if (trait_exists(BarTrait::class) {
    class Foo extends FooUsingBarTrait
    {
    }
} else {
    class Foo extends FooNotUsingBarTrait
    {
    }
}

Create your instance

$foo = new Foo();

$foo->bar();

var_dump(
    get_class($foo),
    class_parents(Foo::class)
);

Note This probably makes most sense if both classes FooUsingBarTrait and FooNotUsingBarTrait implement a common interface - after all, you probably want to provide some functionality which will be shared between the two implementations: one using a trait, the other by other means (methods provided by that class).

For reference, see:

• http://php.net/manual/en/function.class-parents.php
• http://php.net/manual/en/function.trait-exists.php

For examples, see:

• https://3v4l.org/fCLkt
• https://3v4l.org/f77cn

Answer 2

Your question is fun, and eval() likely meets your needs. This style using code generation is ugly, but I know it works because I verified it myself on my own machine. Here's how you can do it:

$src = '
class foo {
  var $bar; // and all of your other code goes here
';
if (file_exists('myTrait.php')) {
  include_once('myTrait.php');
  $src .= "use myTrait;\n";
}
$src .= "}";
eval ($src); // your class finally gets declared

I don't use eval() often, but it's fun when it solves a problem that otherwise cannot be conventionally solved.

Answer 3

no matter how bad it is, you can do it by extending the class.

trait AutoPilot {
   function navigate() {
       echo 'navigating...';
   }
}

if (trait_exists('AutoPilot')) {
   class Machine {
       use AutoPilot;
   }
} else {
   class Machine {
   }
}

class Car extends Machine {
}


$car = new Car;
$car->navigate();

Answer 4

Here what i've ended up with :

eval("class myClass {" 
    . (trait_exists('myTrait') ? "use myTrait;" : "") 
    . str_replace(['class ', '<?php'], '//', file_get_contents(myClass.php"))
);

Total lazyness:

• Duplicate trait_exists line to add more traits
• Comments out the class keyword and the <?php tag so you don't have to edit the class file
• evaluates the one long line of smelly code.

This works just fine for me and 'as is' without any modification to any file except the one i paste this line in. It will probably won't be the case for you.

Consider the fact that:

• don't use closing php tag
• only one class by file
• you need to add any other keywords (extends, implements,...)
• and probably way more unexpected behaviour depending on your code

Thanks to lacalheinz for his instructive post but Steven aimed at the bulleyes with eval().