verschachtelte Funktion mit Rückgabewerten

[mir]

moin!

hab ein script in diesem stil:

function f_test($testwert)
{
   //viel code-zeugs
     f_test("wert2")
   return $back//... viel code-zeugs
}
rueckgabe = f_test("wert1");

nun erhalte ich allerdings nur den rückgabewert der "äußeren" funktion.
also dachte ich mir, dass sich array_merge eignen sollte,
doch auch das is fürn a...:

function f_test($testwert)
{
   //viel code-zeugs
     array_merge($back ,f_test("wert2"));
   return $back//... viel code-zeugs
}
rueckgabe = f_test("wert1");

nun weiß ich nicht, was ich tun soll, deswegen frag ich ;-)

dankeschön

[Matze]

Servus,

so ganz verstehe ich Dein Problem nicht vielleicht etwas anderster Formulieren.

Jedoch vermute ich folgenden Denkfehler:

Du rufst function f_test(XY) auf.

dieser ruft wiederum sich und wieder sich und wieder sich.

1. Der Code nach return xy;  wird nicht mehr ausgeführt.
2. Sieht es so aus:

f_test
(
  f_test
  (
     f_test
     (
     )
  )
)

Mit dem obigen "Script möchte ich demonstrieren, das die funktionen jeweils eine Intanz innerhalb der jeweils äussern sind.

so wie Du hinen gehst gehst du auch wieder zurück schritt für schritt.
Wenn ich Deine idee richtig verstanden habe willst du soetwas haben...

f_test
(
  f_test
  (
     f_test
     (
       return returnwert;
     )
    returnwert = f_test
    return returnwert;
  )
 returnwert = f_test
 return returnwert;

)

Ich hoffe nicht zu verwirrend je nach Programiersprache ist eine Überlagerung so nicht möglich, wie Du es bräuchtest. Würde aber generll auch nicht überlagerungsfähig werden auss die letzte Funktion  der Verschachtelung hat einen andern aufrufparameter Typ und kann somit identifiziert werden.

aber egal So wie ich es verstanden hae, willst Du den wert der innersten funktion wieder völig nach aussen bringen...

Vergiss das sofort Das mus man absolut vermeiden und ist auch völlig unsinnig.

Ich führe jett kein Referat darüber aber glaube es mir es spricht sehr viel dagegen.

Gruss Matze

[Sven Rautenberg]

Moin!

function f_test($testwert)
{
   //viel code-zeugs
     f_test("wert2")
   return $back//... viel code-zeugs
}
rueckgabe = f_test("wert1");

nun erhalte ich allerdings nur den rückgabewert der "äußeren" funktion.
also dachte ich mir, dass sich array_merge eignen sollte,
doch auch das is fürn a...:

function f_test($testwert)
{
   //viel code-zeugs
     array_merge($back ,f_test("wert2"));
   return $back//... viel code-zeugs
}
rueckgabe = f_test("wert1");

Du mußt irgendeinen Mechanismus haben, der es dir erlaubt, das zu befüllende Array auch in die inneren Funktionsaufrufe hineinzutragen.

Bislang passiert folgendes:
f_test
  $back ist leer
  fügen hinzu den Wert von
  f_test
    $back ist leer
    füge hinzu den Wert von
    f_test
      $back ist leer
      Abbruch der Schleife.
      gebe $back zurück
    gebe $back zurück
  gebe $back zurück
gebe $back zurück

Und das Resultat ist: Du gibst an alle Funktionen jeweils ein leeres $back zurück, was mit einem ebenfalls leeren $back der äußeren Funktion zusammengeführt ebenfalls leer ist - und sich niemals füllt.

Wenn du ein Array anreichern willst, hast du drei Möglichkeiten, um auf den bisherigen Zustand zuzugreifen:

1. globale Variable. WÜRG! ÖRKS! Bloß nicht! Aber es geht natürlich:
$back = array();
function f_test(...)
{
  global $back
  ...der Rest wie gehabt...
}

Das wirklich üble an dieser Methode ist, dass dieser Code eben in einer globalen Variable herumpfuscht, die Funktion damit auf äußere Bedingungen (nämlich den Namen dieser Variablen) angewieden ist und somit nicht mehr beliebig einsetzbar ist.

2. Übergabe des Arrays als weiterer Parameter:

function f_test($testwert,$back)
{
  array_merge($back ,f_test("wert2",$back));
  return $back;
}

$array = f_test("wert1",array());

Das ändert deinen Funktionsaufruf, und es ist auch nicht unbedingt schön, ständig das Array zu kopieren.

3. Übergabe des Arrays als Referenz - funktioniert im Prinzip genauso:

$array = array();

function f_test($testwert,&$back)
{
  array_merge($back ,f_test("wert2",$back));
  return $back;
}

f_test("wert1",$array);

Mit Referenzen wird der Funktion nicht eine Kopie der Variablen übergeben, sondern ein Zeiger auf die tatsächliche Variable - die Funktion ändert die globale Variable.

Außerdem mußt du zwingend eine existierende Variable (und keine Konstante) an die Funktion übergeben.

Wenn du das Funktionsinterface nicht mehr ändern kannst, besteht die Möglichkeit, deine alte Funktion als Wrapper zu benutzen, um darin solch eine Variable lokal zu definieren und dann die neue Funktion aufrufen.

- Sven Rautenberg