Mehrere Argumente im Funktionsaufruf gegen ein einzelnes Array

Ich habe eine Funktion, die eine Reihe von Parametern aufnimmt und diese dann als Bedingungen für eine SQL-Abfrage anwendet. Ich bevorzuge jedoch ein einzelnes Argument-Array, das die Bedingungen selbst enthält:

function searchQuery($params = array()) {
    foreach($params as $param => $value) {
        switch ($param) {
            case 'name':
                $query->where('name', $value);
                break;
            case 'phone':
                $query->join('phone');
                $query->where('phone', $value);
                break;
        }
    }
}

Mein Kollege hat es vorgezogen, alle Argumente explizit aufzulisten:

function searchQuery($name = '', $phone = '') {
    if ($name) {
        $query->where('name', $value);
    }

    if ($phone) {
        $query->join('phone');
        $query->where('phone', $value);
    }
}

Sein Argument war, dass durch die explizite Auflistung der Argumente das Verhalten der Funktion offensichtlicher wird - anstatt sich mit dem Code befassen zu müssen, um herauszufinden, was das mysteriöse Argument $paramwar.

Mein Problem war, dass dies sehr ausführlich wird, wenn man mit vielen Argumenten wie 10+ umgeht. Gibt es eine bevorzugte Praxis? In meinem Worst-Case-Szenario würde etwa Folgendes auftreten:

searchQuery('', '', '', '', '', '', '', '', '', '', '', '', 'search_query')

IMHO ist Ihr Kollege für das obige Beispiel richtig. Ihre Präferenz mag knapp sein, aber es ist auch weniger lesbar und daher weniger wartbar. Stellen Sie die Frage, warum Sie sich überhaupt die Mühe machen, die Funktion zu schreiben, was Ihre Funktion "auf den Tisch bringt" - ich muss verstehen, was sie tut und wie sie es ausführlich tut, nur um sie zu verwenden. Mit seinem Beispiel kann ich, obwohl ich kein PHP-Programmierer bin, genügend Details in der Funktionsdeklaration erkennen, so dass ich mich nicht um deren Implementierung kümmern muss.

Bei einer größeren Anzahl von Argumenten wird dies normalerweise als Codegeruch betrachtet. Normalerweise versucht die Funktion zu viel zu tun? Wenn Sie tatsächlich eine große Anzahl von Argumenten benötigen, ist es wahrscheinlich, dass sie in irgendeiner Weise zusammenhängen und in einer oder wenigen Strukturen oder Klassen zusammengehören (möglicherweise sogar in einer Reihe zusammenhängender Elemente, wie z. B. Zeilen in einer Adresse). Das Übergeben eines unstrukturierten Arrays hat jedoch keine Auswirkung auf die Codegerüche.

Meine Antwort ist mehr oder weniger sprachunabhängig.

Wenn der einzige Zweck der Gruppierung von Argumenten in einer komplexen Datenstruktur (Tabelle, Datensatz, Wörterbuch, Objekt ...) darin besteht, sie als Ganzes an eine Funktion zu übergeben, sollten Sie dies besser vermeiden. Dies fügt eine nutzlose Komplexitätsebene hinzu und macht Ihre Absicht undeutlich.

Wenn die gruppierten Argumente eine eigene Bedeutung haben, hilft diese Komplexitätsebene beim Verständnis des gesamten Designs: Nennen Sie sie stattdessen Abstraktionsebene.

Möglicherweise stellen Sie fest, dass anstelle von einem Dutzend einzelner Argumente oder eines großen Arrays das beste Design zwei oder drei Argumente sind, die jeweils korrelierte Daten gruppieren.

In Ihrem Fall würde ich die Methode Ihres Kollegen vorziehen. Wenn Sie Modelle schreiben und ich Ihre Modelle verwende, um sie zu überarbeiten. Ich sehe die Unterschrift der Methode Ihres Kollegen und kann sie sofort verwenden.

Währenddessen müsste ich die Implementierung Ihrer searchQueryFunktion durchgehen, um zu sehen, welche Parameter von Ihrer Funktion erwartet werden.

Ich würde Ihren Ansatz nur in dem Fall bevorzugen, in dem searchQuerynur innerhalb einer einzelnen Tabelle gesucht werden soll, sodass es keine Verknüpfungen gibt. In diesem Fall würde meine Funktion so aussehen:

function searchQuery($params = array()) {
    foreach($params as $param => $value) {
        $query->where($param, $value);
    }
} 

Ich weiß also sofort, dass die Elemente von array tatsächlich die Spaltennamen einer bestimmten Tabelle sind, die die Klasse mit dieser Methode in Ihrem Code darstellt.

Tun Sie beides. array_mergeErmöglicht eine explizite Liste am oberen Rand der Funktion, die Ihrem Kollegen gefällt, und verhindert, dass die Parameter nach Belieben unhandlich werden.

Ich empfehle auch dringend, @ chiborgs Vorschlag aus den Fragenkommentaren zu verwenden - es ist viel klarer, was Sie beabsichtigen.

function searchQuery($params = array()) {
    $defaults = array(
        'name' => '',
        'phone' => '',
        ....
    );
    $params = array_merge($defaults, $params);

    if(!empty($params['name'])) {
        $query->where('name', $params['name']);
    }
    if (!empty($params['phone'])) {
        $query->join('phone');
        $query->where('phone', $params['phone']);
    }
    ....
}

Sie können auch eine Zeichenfolge übergeben, die einer Abfragezeichenfolge ähnelt, und verwenden parse_str(da Sie anscheinend PHP verwenden, andere Lösungen jedoch wahrscheinlich in anderen Sprachen verfügbar sind), um sie in ein Array innerhalb der Methode zu verarbeiten:

/**
 * Executes a search in the DB with the constraints specified in the $queryString
 * @var $queryString string The search parameters in a query string format (ie
 *      "foo=abc&bar=hello"
 * @return ResultSet the result set of performing the query
 */
function searchQuery($queryString) {
  $params = parse_str($queryString);
  if (isset($params['name'])) {
    $query->where('name', $params['name']);
  }
  if (isset($params['phone'])) {
    $query->join('phone');
    $query->where('phone', $params['phone']);
  }
  ...

  return ...;
}

und nenne es wie

$result = searchQuery('name=foo&phone=555-123-456');

Mit können Sie http_build_queryein assoziatives Array in eine Zeichenfolge konvertieren (umgekehrt parse_str).