Ankündigung

Einklappen
Keine Ankündigung bisher.

Referenz auf Funktion übergeben

Einklappen

Neue Werbung 2019

Einklappen
X
Einklappen
  • Seite von 1
  • Filter
  • Zeit
  • Anzeigen
Alles löschen
neue Beiträge
Vorherige Weiter
  • #1

    Referenz auf Funktion übergeben

    Hi,

    ich bin neu hier und erstmal "Hallo"

    folgendes Problem:

    Ich habe mehrere Funktionen für die ich mitloggen will, was sie Parameter etc. bekommen haben. Ich würde nun gerne eine Art Referenz der Funktion in der ich gerade bin an die Funktion geben, die das loggen macht.

    bis jetzt habe ich es so

    $numArgs = func_num_args();
    $argList = func_get_args();

    // now call the wrapped soap function
    $h_checkBankResult = $this->callWrapper('checkBank',$o_soap,$params,$numArgs, $argList);

    in der callWrapper lese ich dann alles aus etc.

    ich würde aber gerne auf die zeilen

    $numArgs = func_num_args();
    $argList = func_get_args();

    verzichten und eine art referenz der funktion übergeben in der ich gerade bin, so dass ich bei Änderrungen nicht alle Funktionen anfassen muss. Die funktion callWrapper hätte dann die Möglichkeit genauso mit den funktionen

    $numArgs = func_num_args();
    $argList = func_get_args();


    auf die ursprüngliche funktion zuzugreifen.

    so in der Art

    // now call the wrapped soap function
    $h_checkBankResult = $this->callWrapper('checkBank',$o_soap,$params,$numArgs, $argList,&$thisFunction);

    Kann mir da jemand helfen oder geht das generell nicht ?

    ciao und danke

    Marcel
    Stichworte: -
  • #2
    Also du willst von jeder Funktion die übergebenden Parameter loggen, aber nicht jede Funktion so verändern das die deine Logging Funktion aufruft, da zuviel Code ? Also ne Referenz gibt es (wahrscheinlich) nicht in PHP, man kann zwar auf die Referenz von Variablen in PHP zugreifen, aber auf die Funktion ... ich glaube nicht. Du könntest aber alle Funktionsaufrufe an eine Logger Funktion als String übergeben, und diesen nach den Loggen mit nem Eval ausführen:

    PHP-Code:
    <?

    function Log($Func) {
       /* Logging .... */

      eval($Func);
    }

    function FuncDummy($Parm1) {
      /* Do nothing */
    }

    Log("Funcdummy(Test);");

    ?>

    Kommentar

    • #3
      ...und wie willst du so ein Objekt an die Funktion übergeben etc.? Du müsstest schon die Ausgabe von get_args() serialisieren, aber dann stehst du vor dem nächsten Problem: Als Referezen übergebene Parameter und das kannst du so nicht lösen.

      Ehrlich gesagt weiß ich auch nicht, ob es das ist, was Marcel meinte.

      Du hast ein Objekt und rufst eine Methode dieses auf. Diese Methode ruft nun einen Wrapper auf (in dem Fall eine Methode des selben Objektes), der den Aufruf loggt und die Parameter an eine bestimmte Funktion weitergibt, richtig?

      Auch hier wirst du an den Paremetern scheitern, die du als Referenzen übergibst, denn du hast aus der Funktion heraus ja keine Möglichkeit festzustellen, ob der Parameter als Referenz übergeben wurde oder nicht.

      Wieso überhaupt reicht es nicht, der logging-Funktion die Ausgabe von get_args() zu übergeben? Den Funktionsnamen kannst du von dort aus dann mit debug_backtrace() auslesen und schon hast du alle Infos oder wo ist das Problem?

      Basti

      Kommentar

      • #4
        ich meinte es so

        Hi,

        erstmal danke für eure Antworten.

        Ich meinte das so:

        Um nicht in jeder Funktion die Parameter die sie bekommen hat zu ermitteln und dies in jeder Funktion zu tun, würde ich gerne ein Wrapper funktion bauen, welche als argument den Namen der eingentlichen Funktion hat. Die Wrapper funktion kann soll dann auf die Funktion aus der sie aufgerufen wurde zugreifen und deren Parameter ermitteln und loggen.

        Also anstatt in jeder Funtion die ich mal aufrufe

        numArgs = func_num_args();
        $argList = func_get_args();

        zu schreiben und diese dann zusätzliche als parameter an die wrapper funktion zu übergeben, wie hier

        // now call the wrapped soap function
        $h_checkBankResult = $this->callWrapper('checkBank',$o_soap,$params,$numArgs,$argList);


        würde ich einfach gerne folgendes schreiben:

        numArgs = func_num_args();
        $argList = func_get_args();

        // now call the wrapped soap function
        $h_checkBankResult = $this->callWrapper('checkBank',$o_soap,$params,&$THIS_OD ER_SO);

        $numArgs,$argList fehlen in diesem Aufruf, da ich sie im Wrapper holen will.

        Im Wrapper würde ich dann soetwas schreiben wollen

        function callWrapper('eigentlicheFunktion',$o_soap,$params, $DIE_REF){

        und jetzt hier

        numArgs = func_num_args($DIE_REF);
        $argList = func_get_args($DIE_REF);

        }

        Ich hoffe, jetzt wird es klarer

        danke schonmal

        Marcel

        [/b]

        Kommentar

        • #5
          ...ich denke, die Verwendung des Begriffes 'Wrapper' sogt einfach für Misverständnisse, denn in der Regel rufst du den den Wrapper ja 'von Außen' auf und der greift dann auf die jeweilige Implementierung der Funktionalitäten zurück.

          Wie auch immer, ich kann es nur nochmal wiederholen:
          Es gibt keine Referenzen auf Funktionen und das übergeben der Parameter via func_get_args() oder der Methode von 'GiggyGsk' scheitert an der fehlenden Möglichkier, Referenzen zu übergeben bzw. bei 'GiggyGsk' (zumindest in der Implementierung) eben auch an Arrays und Objekten als Parameter.

          Was willst du denn noch wissen?

          Basti

          Kommentar

          • #6
            danke euch beiden

            danke,

            reicht mir als Antwort. Vielleicht finde ich ja noch ein Möglichkeit.

            danke

            Marcel

            Kommentar

            • #7
              Ich stand kürzlich auch vor dem Problem und habs dann aufgegeben. Wenn du eine Lösung hast, dann poste mal. Ich denke aber, es scheitert einfach an er Unmöglichkiet, eine Referenz auf NULL zu bekommen.

              Hier hab ich mal ein wenig rumgespielt:
              PHP-Code:
              <?php
              function foo($args = array())
              {
                                $backtrace = debug_backtrace();
                  echo               "Die Funktion {$backtrace[1]['function']} wurde mit folgenden Parametern aufgerufen:<pre>";
                                var_dump($args);
                  echo               '</pre>';
              }

              function               bar() 
              {
                                foo(func_get_args());
              }

              function               baz($test)
              {
                                foo(func_get_args());
              }

              echo               '<h1>Aufruf mit "normalen" Parametern aus der einen Funktion</h1>';
              bar ('x', array('y', 'z'), dir('.'));

              echo               '<h1>...und aus der anderen Funktion heraus</h1>';
              baz (0, false, NULL);


              echo               '<h1>Passing by Reference bei fest definierter Anzahl der Argumente</h1>';

              function               foo1 (&$arg)
              {
                                $arg = 42;    
              } 

              function               bar1 (&$arg)
              {
                                foo1($arg);
              }

              $test = 17;
              bar1($test);
              echo               "Wert wird erfolgreich geaendert: $test";

              echo               '<h1>Passing by Reference bei variabler Anzahl der Argumente</h1>';

              function               foo2 (&$args)
              {
                                $args[0] = 42;    
              } 

              function               bar2 (&$arg1)
              {
                                foo2(func_get_args());
              }

              $test = 17;
              bar2($test);
              echo               "Hier gehen die Referenzen natuerlich floeten: $test";

              echo               '<h1>Workaround</h1>';
              echo               'kann natuerlich nicht gehen, da du keine Referenz auf NULL haben kannst';

              function               foo3 (&$arg1, &$arg2, &$arg3, &$argn)
              {
                                $arg1 = 42;
              }


              function               bar3 (&$arg)
              {
                                foo3($arg);
              }

              $test = 17;
              bar3($test);
              ?>

              Kommentar

              • #8
                danke für den Code, werde ihn probieren n.T.

                danke

                Marcel

                Kommentar

                Vorherige Weiter
                Lädt...
                X