Funktion request(), Verbesserungsvorschläge?

[Griecherus]

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):

function request($sources, $name, $presetting = NULL)
{
    $request_sources = array('g' => $_GET, 'p' => $_POST, 'c' => $_COOKIE);
    $sources = preg_split('//', $sources, -1, PREG_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.

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.

[onemorenerd]

Willkommen!

Nach den Anforderungen an die Funktion genügt doch auch folgendes:

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

$u = isset($_GET['username']) 
      ? $_GET['username'] 
      : isset($_POST['username']) 
         ? $_POST['username'] 
         : false; 

[Griecherus]

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:

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.