Un'alternativa a una serie di funzioni?

Espansione sul commento di @ lortabac:

Puoi passare i puntatori alle funzioni semplicemente passando il nome della funzione, ad esempio:

function fn1()
{
    // ...
}

function fn2($fn)
{
    $fn();
}

fn2(fn1);

Quindi dovresti essere in grado di popolare la tua matrice in questo modo:

$functions = [
    "do this" => fn1,
    "do that" => fn2
]

oppure, se si desidera essere in grado di chiamare le funzioni utilizzando i riferimenti impostati nell'array, è possibile definire prima l'array, quindi scrivere le funzioni, quindi impostare i riferimenti alle funzioni in l'array dopo.

Prima di tutto, secondo il principio DRY, dovresti provare a rendere le tue funzioni ancora più simili, in modo che possano condividere il maggior numero possibile di codice. Ciò renderà la gestione della base di codice abbastanza semplice, che non può essere detta in merito al numero di funzioni "simili ma diverse".

La possibile soluzione al tuo problema è racchiudere tutte le tue funzioni in una classe e renderle pubblicamente richiamabili con un solo nome. Il modo più pulito per farlo nella tua situazione è definire il metodo call , che chiamerà quindi la funzione appropriata, trovata usando il metodo magico __get . È bello ed è sicuro (beh, dipende dall'implementazione).

Stai essenzialmente chiedendo quando e come filiale . Il mio suggerimento generale sarebbe:

• scrivi il codice solo una volta ( DRY ).
• chiama il codice-che-determina-come-il-codice-rami una volta e poi non si dirama di nuovo.
• considera l'utilizzo del Pattern di strategia o Modello di comando .

Con un approccio orientato agli oggetti (secondo i pattern), la decisione di ramificazione potrebbe essere controllata da una classe SomethingStrategyManager , che ti darà un'istanza di ISomethingStrategy . Quindi eseguirai il metodo ISomethingStrategy doTheThing .

In pseudo-codice molto generico:

interface IMyStrategy:
  method doTheThing(string name); //returns a BOOLEAN value
  ... //maybe this interface can have more methods?

class MyStrategyManager:
  method getStrategyForSomeArgs(int a, string c) //returns IMyStrategy
     if (a % 2 == 0) return new EvenNumberStrategy();
     else if (a.isPrimeNumber) return new PrimeNumberStrategy();
     else if (c == "CustomSomething") return new CustomStrategy();
     else return new DefaultStrategy();    

...

// Using the strategies:
IMyStrategy strategy = MyStrategyManager.getStrategyForSomeArgs(3, "foo");
BOOL success = strategy.doTheThing("john smith");
... 

Potresti creare una classe che racchiuda tutte le tue funzioni e poi chiamarle come metodi dell'oggetto

class SimpleFunctions {

  public function doThis() {
    // Do this
  }

  public function doThat() {
    // Do that
  }

  public function doThisInThat() {
    // Do this in That
    $this->doThis();
  }
}

$funcs = ['doThis', 'doThat', 'doThisInThat'];
$simpleFunctions = new SimpleFunctions();
foreach($funcs as $f) {
  if(!method_exists($simpleFunctions, $f))
    throw new \Exception(sprintf("Method %s not found in %s", $f, get_class($simpleFunctions));

  $simpleFunctions->$f();
}

Penso che, nel tuo ciclo FOREACH, puoi aggiungere

$method = '_' . <function name><key>;

if (method_exists($this, $method)) {
    $this->$method();
}
else {
    show_error('Could not load Method' . $method);
}

Algorithm / Logic: la variabile '$ method' memorizzerà il nome della funzione e la chiave disponibile che alla fine può funzionare come nome di un metodo. La condizione IF controlla semplicemente la disponibilità dello stesso metodo e la apre se il metodo esiste altrimenti genera un errore.

L'aspetto di una classe completa sarà:

public function your_function()
{
        foreach ($program as $k => $v) {
            //$this->call_function($v); // add 'call_function' in your loop
            $method = '_' . fn.$v; //<function name><key>

            if (method_exists($this, $method)) {
                $this->$method();
            }
            else {
                show_error('Could not load template ' . $method);
            }
        }
}   

public function _fnkey()
{
    echo "In Function 1";
}   

Spero che questo sia utile!

Penso che un modo migliore sia di cambiare la matrice in namespace. In questo modo puoi utilizzare nomi di funzioni normali e chiamate normali da altre funzioni.

Quando è necessaria la chiamata dinamica - usa il riferimento.

namespace foo {
  function f1($a) { print "1\n"; };
  function f2($a) { print "2\n"; f1(3); };
}
namespace bar {
  $f = '\foo\f2';
  $f(2);
}