Comment assigner une fonction membre à un tableau et l'appeler

Question

Je fais actuellement cette façon, mais semble ne pas être la bonne façon:

class Name
{
    protected $jobs2do;

    public function __construct($string) {
        $this->jobs2do[] = $this->do;
    }

        public function do() {
        ...
    }
}

Parce que affecter directement une fonction provoquera avertissement, devrait faire quelque chose comme:

function func()
{
...
}

$func_array[] = 'func';

dire, mettre dans une chaîne, mais je ne sais pas comment le faire quand il est fonction de membre.

La version suivante OK:

class Name
{
    public $jobs2do;

    public function __construct($string) {
        $this->jobs2do[] = array($this,'do');
    }

        public function do() {
        ...
    }
}

appeler, juste:

$instance = new Name();
foreach ($instance->jobs2do as $job)
{
    call_user_func($job);
}

Answer 1

Ecrire une classe pour utiliser Travail le modèle de l'usine pour les créer. Puis Ecrire un JobManager de classe wihich devrait maintenir une liste ob cas d'emplois.

interface iCallableJob
{
    public function run();
}

class Job implements iCallableJob
{
    // The parameterized factory method
    public static function factory($type)
    {
        $classname = 'Job_' . $type;
        if (class_exists($classname) && in_array('iCallableJob', class_implements('Job')))
        {
            return new $classname();
        }
        return null;
    }
    public function run() { return null; }
}

class Job_type1 extends Job 
{
    public function run() 
    {
        echo 'Job 1';
    }
}

class JobManager
{
    protected $jobs2do = array();

    public function addJob($type)
    {
        if ($job = Job::factory($type))
        {
            $this->jobs2do[] = $job;
            return $job;
        }
        return null;
    }
    public function runAll()
    {
        foreach ($this->jobs2do AS $job)
        {
            $job->run();
        }
    }
}

Answer 2

Il y a (au moins) 4 façons de le faire. Il existe d'autres moyens, mais ceux-ci sont les plus purs. Les versions de la méthode nécessitent au minimum PHP5.

class foo {
    public function bar($a) { return $a; }
}

$anObject = new foo();
$ret = call_user_func(array($anObject,'bar'), 1);
$ret = call_user_func_array(array($anObject,'bar'), array(1));
$ret = call_user_method('bar', $anObject, array(1));
$ret = call_user_method_array('bar', $anObjectm, 1);

Vous pouvez remplacer 'bar' avec une variable de chaîne, aussi.

Answer 3

call_user_func () ou call_user_func_array ()

Answer 4

Jetez un oeil à la appelable type pseudo. Vous pouvez ensuite appeler cette fonction avec call_user_func () :

class Foo {
    function bar($str) {
        echo($str);
    }
}

$foo = new Foo();
$func_array = array();
$func_array['foo->bar'] = array($foo, 'bar');  // this is the 'callable' pseudo-type

call_user_func($func_array['foo->bar'], "Hello World");

Modifier Il semble que vous essayez de mettre en œuvre les . Dans ce cas, vous pouvez essayer quelque chose le long de ces lignes:

// define an interface for all actions
interface Executable {
    public function do();
}

// an example action
class DoSomething implements Executable {
    private $name;

    public __construct($name) {
        $this->name = $name;
    }

    public function do($str) {
        echo("Hello $str, my name is $this->name");
    }
}

$objects_to_process = array(new DoSomething("Foo"), new DoSomething("Bar"));
foreach ($objects_to_process as $obj) {
    if ($obj instanceof Executable)
        $obj->do("World");
}

Answer 5

Il peut y avoir plusieurs solutions possibles à ce problème. Vous avez des modèles de commande et d'usine présentés dans d'autres réponses. Celui-ci illustre comment utiliser visiteur + commande coopération motif.

class Name {

    protected $jobs = array();

    public function addJob(IJob $j) {
        $this->jobs[] = $j;
    }

    public function do() {
        foreach ($this->jobs as $j) {
            $j->run($this);
        }
    }

}

interface IJob {

    public function run(Name $invoker);

}

class WashDishes implements IJob {

    public function run(Name $invoker) {
        echo get_class($invoker) . ' washes dishes<br/>';
    }

}

class DoShopping implements IJob {

    public function run(Name $invoker) {
        echo get_class($invoker) . ' does shopping<br/>';
    }

}

$n = new Name();
$n->addJob(new WashDishes());
$n->addJob(new DoShopping());
$n->do();

Sortie:

Name washes dishes
Name does shopping

Une classe qui implémente l'interface IJob est une commande qui peut être transmise et stockée pour une exécution ultérieure. L'objet Name façon invoque des emplois dans la collection (passant référence $this) est typique pour le modèle des visiteurs (ainsi objet de travail a accès à son appelant - objet Name). Cependant, le vrai motif des visiteurs est impossible en PHP en raison du manque de prise en charge native pour des raisons impérieuses de méthode explicite.

Answer 6

ne sais pas si cela est la bonne façon. mais c'est comment je fais le mien.

$this->api['google']['+1Button']=function($str)
    {
        echo $str;
    };
    $this->api['google']['+1Button']("hello world");