Funktion request(), Verbesserungsvorschläge?

Einklappen
X
 
  • Filter
  • Zeit
  • Anzeigen
Alles löschen
neue Beiträge

  • Funktion request(), Verbesserungsvorschläge?

    Hallo allerseits,

    ich verfolge das Geschehen hier im Forum schon seit einiger Zeit still mit. Mit diesem
    Thema werde ich euch eine Funktion zeigen, die ich geschrieben habe und fragen, ob
    der eine oder andere Verbesserungsvorschläge oder dergleichen hat, da ich noch nicht allzu
    viel Erfahrung mit der Materie habe (Ich habe bewusst nichts ins BS-Forum geschrieben, da
    ein Ansatz ja da ist. Ich hoffe trotzdem, dass ich nicht das falsche Forum erwischt habe.).

    Hier erstmal die Funktion (bisheriger Stand):

    PHP-Code:
    function request($sources$name$presetting NULL)
    {
        
    $request_sources = array('g' => $_GET'p' => $_POST'c' => $_COOKIE);
        
    $sources preg_split('//'$sources, -1PREG_SPLIT_NO_EMPTY);
        foreach (
    $sources AS $source) {
            
    strtolower($source);
            if (isset(
    $request_sources[$source][$name])) {
                if (
    is_array($request_sources[$source][$name])) {
                    foreach (
    $request_sources[$source][$name] AS $key => $value) {
                        
    $data[$key] = $value;
                    }
                } else {
                    
    $data $request_sources[$source][$name];
                    break;
                }
            } else {
                
    $data $presetting;
            }
        }
        return 
    $data;

    Meine Idee war es, eine Funktion zu schreiben, mit der ich mit möglichst wenig
    Schreibaufwand Daten aus den Get- und/ oder Post- und/oder Cookie-Autoglobalen abrufen
    und - falls keine gefunden werden konnten - mit Standardwerten belegen kann.
    Todo: Ein optionaler vierter Parameter $type, der den erwarteten Typ (String, Integer, Boolean, usw.)
    der abzurufenden Daten enthält. Durch Typumwandlung soll dann sichergestellt werden, dass die
    abgerufenen Daten keinem anderen Typ entsprechen.

    Funktionieren tut das Ganze. Ich habe die Funktion auch einem Benchmark unterzogen und bin
    bei 333333 Iterationen auf stolze ~15 Sekunden gekommen. Aus diesem Grund habe ich nach
    einer Alternativen gesucht und bin auf folgendes gestoßen, das bei den Benchmarks mit
    ~6 Sekunden zwar deutlich besser abschneidet, mir aber nicht so "elegant" wie die
    erste Variante erscheint.

    PHP-Code:
    function request($sources$name$presetting NULL) {
        switch (
    strtolower($sources)) {
            case 
    'g':               $source $_GET;                             break;
            case 
    'p':               $source $_POST;                         break;
            case 
    'c':               $source $_COOKIE;                         break;
            case 
    'gp': case 'pg'$source array_merge($_GET,  $_POST);     break;
            case 
    'pc': case 'cp'$source array_merge($_POST$_COOKIE);     break;
            case 
    'gc': case 'cg'$source array_merge($_GET,    $_COOKIE);  break;
        }
        if (isset(
    $source[$name])) {
            if (
    is_array($source[$name])) {
                foreach (
    $source[$name] AS $key => $value) {
                    
    $data[$key] = $value;
                }
            } else {
                
    $data $source[$name];
            }
        } else {
            
    $data $presetting;
        }
        unset(
    $source);
        return 
    $data;

    EDIT:
    Ich habe ein kleines Anwendungsbeispiel vergessen:
    $username = request('gp', 'username', ''); Würde sowohl im Get- als auch im Post-Array nach dem Key 'username' suchen und diesen $username zuordnen. Falls keiner gefunden werden konnte, enthält $username eine leere Zeichenkette.



    Ich würde mich über jede Meinung und jeden Vorschlag freuen.
    Zuletzt geändert von Griecherus; 23.02.2006, 15:09.
    Nieder mit der Camel Case-Konvention

  • #2
    Willkommen!

    Nach den Anforderungen an die Funktion genügt doch auch folgendes:
    PHP-Code:
    function request($src$name) {
      if (
    strpos($src'g') !== false && isset($_GET[$name]))
        
    $val $_GET[$name];
      if (
    strpos($src'p') !== false && isset($_POST[$name]))
        
    $val $_POST[$name];
      if (
    strpos($src'c') !== false && isset($_COOKIE[$name]))
        
    $val $_COOKIE[$name];
      return isset(
    $val) ? $val false;
    }

    $username request('gp''username'); 
    Allerdings sollte bei sauberer Programmierung sowas überhaupt nicht nötig sein. Man weiß doch stets, woher gewünschte Daten kommen und falls es doch mal GET oder POST sein kann, dann macht man eben
    PHP-Code:
    $u = isset($_GET['username']) 
          ? 
    $_GET['username'
          : isset(
    $_POST['username']) 
             ? 
    $_POST['username'
             : 
    false

    Kommentar


    • #3
      Danke für deinen Verbesserungsvorschlag. Auf die Idee, $sources mittels
      strpos nach den Vorkommen der Kürzel g, p und c zu suchen, bin ich nicht gekommen.

      Viel wichtiger ist mir aber dein Argument der sauberen Programmierung. Die Idee, in
      mehreren Quellen zu suchen ist mir erst bei einem Login-Skript gekommen. Es sollten
      sowohl Post als auch Cookie (zwecks Dauer-Login) nach den Login-Daten durchsucht werden.
      Und dafür reicht dein Vorschlag (verschachtelter ?:-Operator) voll und ganz aus.

      Da Type-Casting (in der von mir bereit gestellten Version noch nicht implementiert) aber
      ein wichtiger Baustein der Funktion sein sollte, habe ich die Grundidee nicht verworfen,
      sondern eine neuen (rekursiven) Ansatz erarbeitet. Nun wird nur noch eine Quelle durchsucht und bei
      fehlendem Vorkommen der gesuchten Daten ein Wunschwert zugeordnet. Ebenso kann durch die
      jeweilige Konstante der gewünschte Typ angegeben werden:

      PHP-Code:
      define('REQ_STR''1');
      define('REQ_STR_NO_TRIM''2');
      define('REQ_STR_NO_HTML''3');

      function 
      request(&$source$name$default NULL$type NULL)
      {
          if (isset(
      $source[$name])) {
              if (
      is_array($source[$name])) {
                  foreach (
      array_keys($source[$name]) AS $key) {
                      
      request($source[$name], $key$default);
                  }
              } else {
                  switch (
      $type) {
                      case 
      REQ_STR_NO_TRIM$source[$name] = strval($source[$name]); break;
                      case 
      REQ_STR$source[$name] = strval(trim($source[$name])); break;
                      case 
      REQ_STR_NO_HTML$source[$name] = strval(trim(strip_tags($source[$name]))); break;
                  }
              }
              return 
      $source[$name];
          } else {
              return 
      $default;
          }
      }

      $_POST['demo'] = '<b>A string including html-tags</b>';
      $demo request($_POST'demo'''REQ_STR_NO_HTML);
      // echo $demo; Gibt A string incl... ohne HTML-Formatierung aus.
      // Die Typumwandlung ist natürlich beliebig ausbaufähig, in meinem Beispiel wurde
      // nur der Typ String berücksichtigt. 
      Sicherlich keine lebensnotwendige, aber hilfreiche Funktion.
      Falls noch jemand einen Kommentar zu der Funktion hat, bedanke ich mich im Voraus. Ansonsten
      gibt es von meiner Seite aus keine Fragen mehr. Danke nochmal für den Denkansporn, onemorenerd.
      Nieder mit der Camel Case-Konvention

      Kommentar

      Lädt...
      X