dynamically loading function code into class - php

Question

I am trying to write class code that can dynamically load external function code
to use as methods of the class. I understand that I could use extends and create
child objects, but it seems there would be a simpler way of going about this.
The point is to limit to bare essentials the amount of code that has to be
used to perform a particular function. And keep all the function code in separate files
that can be required.
class _DEMO
{
public $_addOn = '';
public function __construct()
{
require_once('DEMOAdd.php');
$this->addOn = addOn;
}
}
In DEMOAdd.php:
function addOn($_input)
{
return 'getting '.$_input;
}
How would I load this into the _DEMO class? The above produces fatal error.
print $_test->addOn('something');
In JavaScript it is possible to assign a function to a variable. I realize this
is not JavaScript, but I suspect there is analogous functionality in PHP.
I am also aware of variable variables in PHP but I am having trouble wrapping my brain around that concept.
In response to this advice
When another developer looks at your code it is just not clear what the particular role of this class is. Instead he has to inspect many files and external functions referenced in the class. It just would be better if he could take a look at the class and see "oh, that class does this and that". That's even a central aspect of object oriented programming.
I agree with you on this. I am working on a project that I am the only developer of everything, html, javascript, css,
and php. I have been using class definitions lately, but have written lots of procedural code in the past. The current
project has code that is sectioned off into several class def files so code can be reused in different contexts. My
consideration is if a query from a web page only needs 500 lines of code, why load 1500 lines of code to service the
request. Additionally, this is a cms system with a very limited amount of users (only me at present), so the volume
of traffic is not an issue. But if there was a larger user load, for each user extra code is required, thus the amount
of server memory require increased significantly. The cms web interface is to manage content that direct revision of code
would be very difficult. Yes, I am reinventing the wheel. So has Firestone, General, Nokian, etc etc etc.
Thank you all for the answers
I think I have the answer in anonymous functions that can be assigned to variables, re the php manual
$_var = function($_input)
{
return "getting ".$_input;
}
print $_var('something'); // I have to look back at the manual to varify this line's syntax... yep it looks good.

Answer 1

By using inheritance. You can extend the _DEMO class like this:
class _DEMO_ADD extends _DEMO {
...
function addOn(....) {
...
}
See docs on extends.

Answer 2

Designing the application properly
First of all. What you're trying to do violates fundamental aspects of clean object oriented design. Why even use a class when it's only purpose is to call an external function? If you want to proceed with it stick to functional programming.
The point is to limit to bare essentials the amount of code that has to be used to perform a particular function. And keep all the function code in separate files that can be required.
The attempt of good design is not (only) the amount of code you write, but rather how a certain task is achieved. If a class is suitable for solving your problem then use a class.
When another developer looks at your code it is just not clear what the particular role of this class is. Instead he has to inspect many files and external functions referenced in the class. It just would be better if he could take a look at the class and see "oh, that class does this and that". That's even a central aspect of object oriented programming.
Okay. Enough for off-topic. Since you ask especially for that certain problem I'll give you a few advices on that altough I don't recommend it and would advise to rethink your design.
Dynamic method calls
To call a function that has been defined somewhere else we will make use of the magic method __call($methodname, $args). This method will be called whenever you try to access classes method that does not exists.
Within this __call() method we will check if a function with the name of the method exists, we were trying to call. If not we can throw an Exception, otherwise we're going to execute the function using call_user_func_array().
functions.php
<?php
function addOn($input){
echo "This function is procedural and takes the param: " . $input;
}
MyClass.php
<?php
class MyClass{
// This will get called whenever a method on this class
// is called that does not exist
public function __call($name, $args)
{
// Let's check if a function called like the method we wanted
// to call exists somewhere
if(!function_exists($name))
{
// No? So let's raise an Exception
throw new Exception("The function you called " . $name . " does not exist");
}
// Such a function seems to exist so call it and pass
// the arguments
call_user_func_array($name, $args);
}
public function __construct()
{
// Call undefined method
$this->addOn('My Input');
}
}
index.php
<?php
include 'functions.php';
include 'MyClass.php';
$cls = new MyClass();

Answer 3

Here it is, but with some limitations though...
<?php
class SomeClass
{
private $_funcs = array();
public function setFunc($name,$func)
{
$this->_funcs[$name] = $func;
}
public function __call($name, $param)
{
if(!function_exists($name))
{
if(isset($this->_funcs[$name]))
$this->_funcs[$name]();
else echo "NO $name <br />";
}
}
public function dummy()
{
echo 'DUMMY<br />';
}
}
Then let's test this:
$sc = new SomeClass();
$sc->haha();
$sc->dummy();
$sc->setFunc('foo',function(){echo 'Hello New World!';});
// blah blah blah...
// blah blah blah...
// blah blah blah...
// blah blah blah...
// blah blah blah...
$sc->foo();
One of the limitation that I thought of is how to determine if you want to return a result from $sc level or not.
The result should be, based from the code above:
NO haha
DUMMY
Hello New World!
NOTE: I know this is not the best practice, OP, you should know it too. I just answered OP's question.
EDIT: To be able to determine if the function should return something, try taking advantage of the function name like r_sum with a prefix of r_ to determine that it needs to return something.
Example:
public function __call($name, $param)
{
if(!function_exists($name))
{
if(isset($this->_funcs[$name]))
{
if(strpos($name, 'r_')===0)
return $this->_funcs[$name](); // execute and return
else
$this->_funcs[$name](); // just execute
}
else echo "NO $name <br />";
}
}
But now, the other issue of this that I almost forgot, you cannot access the class properties via, new funcs.
SUGGESTION
Group your similar or related functions together into one static class so you can reuse your codes anytime anywhere.
//APP contains functions designed closely to work with your CMS
// example
APP::abort();
// HTML contains functions like getting page title, external reso, etc
// example
echo HTML::getTitle();
// ROUTE contains many routing reqs that you may need
// example
ROUTE::to('heaven');
// many more...