Dynamic class extend - php

Question

Is there a way to define a class so that it extends another class only if that other class is available?

Answer 1

There is nothing that would allow you to do
class Foo extendsIfExist Bar
But you can monkeypatch Foo with runkit's
runkit_class_adopt — Convert a base class to an inherited class, add ancestral methods when appropriate
Example from PHP Manual:
class myParent {
function parentFunc() {
echo "Parent Function Output\n";
}
}
class myChild {
}
runkit_class_adopt('myChild','myParent');
myChild::parentFunc();
The runkit extension is available from PECL. However, it's use is discouraged because needing it is almost always an indicator for a flawed design.
Disclaimer: I am only assuming something like the following example is the reason why you are asking your question. Disregard that part of the answer if it's not.
If you need certain functionality conditionally at runtime, consider aggregating the class you want to extend from, e.g. try something along the lines of
interface Loggable
{
public function log($message);
}
class Foo implements Loggable
{
protected $logger;
public function setLogger($logger)
{
$this->logger = $logger;
}
public function log($message)
{
if($this->logger !== NULL) {
return $this->logger->log($message);
}
}
}
In the example above, the functionality we want is log(). So instead of detecting if a logger class is available and then monkeypatching this functionality into our Foo class, we tell it to require this functionality by adding an interface Loggable. If a Logger class exists, we instantiate and aggregate it in Foo. If it doesnt exist, we can still call log but it wont do anything. This is much more solid.

Answer 2

I did it on this way.
if (class_exists('parentClass') {
class _myClass extends parentClass {}
} else {
class _myClass {}
}
class myClass extends _myClass
{
...
}

Answer 3

This is an answer and an extention to Pekka's answer.
Firstly at Pekka, i think the eval is totally wrong, what is wrong with
if(class_exists("bar"))
{
class foo extends bar
{
}
}
that is also my answer aswell.

Answer 4

Encountered a similar requirement recently, where a class in my library needed to dynamically extend from ClassB (if exists), otherwise extend from Class A.
My solution (my code is namespaced, same concept applies regardless):
namespace someNamespace;
spl_autoload_register(function($class) {
if (strcasecmp($class, 'someNamespace\SomeFakeClass') === 0) {
if (class_exists('ClassB',false)) {
class_alias('ClassB', 'someNamespace\SomeFakeClass');
} else {
class_alias('ClassA', 'someNamespace\SomeFakeClass');
}
}
}, true, true);
/** #noinspection PhpUndefinedClassInspection */
/** #noinspection PhpUndefinedNamespaceInspection */
class MyClass extends \someNamespace\SomeFakeClass {
# ... real logic here ...
}
Using the above solution, the class MyClass will dynamically inherit from ClassB if exists, otherwise it inherits from ClassA.
This solution avoids using eval, which is a big plus for me.
Hope this helps.
EDIT: Just a note, the #noinspection notation exists so that IDEs such as PHPStorm will not report errors regarding the non-existent class.

Answer 5

Do you mean this?
<?php
class Foo{
}
if( class_exists('Foo') ){
class SubFoo extends Foo{
}
}
if( class_exists('Bar') ){
class SubBar extends Bar{
}
}
$a = new SubFoo; // OK
$b = new SubBar; // Fatal error: Class 'SubBar' not found