Argomenti multipli nella chiamata di funzione vs singolo array

Ho una funzione che accetta una serie di parametri, quindi li applica come condizioni a una query SQL. Tuttavia, mentre ho preferito un singolo array di argomenti contenente le condizioni stesse:

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;
        }
    }
}

Il mio collega ha preferito elencare esplicitamente tutti gli argomenti invece:

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

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

La sua argomentazione era che elencando gli argomenti esplicitamente, il comportamento della funzione diventa più evidente - al contrario di dover approfondire il codice per scoprire quale fosse l'argomento misterioso $param.

Il mio problema era che questo diventa molto dettagliato quando si affrontano molti argomenti, come 10+. C'è qualche pratica preferita? Il mio scenario peggiore sarebbe vedere qualcosa di simile al seguente:

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

IMHO il tuo collega è corretto per l'esempio sopra. La tua preferenza potrebbe essere concisa, ma è anche meno leggibile e quindi meno gestibile. Poni la domanda perché preoccuparsi di scrivere la funzione in primo luogo, che cosa porta la tua funzione al tavolo? Devo capire cosa fa e come lo fa, in grande dettaglio, solo per usarlo. Con il suo esempio, anche se non sono un programmatore di PHP, nella dichiarazione della funzione posso vedere abbastanza dettagli da non dovermi preoccupare della sua implementazione.

Per quanto riguarda un numero maggiore di argomenti, questo è normalmente considerato un odore di codice. In genere la funzione sta cercando di fare troppo? Se trovi un reale bisogno di un gran numero di argomenti, è probabile che siano collegati in qualche modo e appartengano insieme in una o poche strutture o classi (forse anche array di elementi correlati come le righe in un indirizzo). Tuttavia, il passaggio di un array non strutturato non fa nulla per indirizzare gli odori del codice.

La mia risposta è più o meno agnostica della lingua.

Se l'unico scopo del raggruppamento di argomenti in una struttura di dati complessa (tabella, record, dizionario, oggetto ...) è di passarli nel loro insieme a una funzione, meglio evitarlo. Ciò aggiunge un inutile livello di complessità e rende oscura la tua intenzione.

Se gli argomenti raggruppati hanno un significato da soli, allora quel livello di complessità aiuta a comprendere l'intero progetto: chiamalo invece livello di astrazione.

Potresti scoprire che invece di una dozzina di singoli argomenti o un grande array, il miglior design è con due o tre argomenti ciascuno che raggruppa i dati correlati.

Nel tuo caso, preferirei il metodo del tuo collega. Se stavi scrivendo modelli e stavo usando i tuoi modelli per svilupparli. Vedo la firma del metodo del tuo collega e posso usarlo immediatamente.

Mentre, dovrei passare attraverso l'implementazione della tua searchQueryfunzione per vedere quali parametri sono previsti dalla tua funzione.

Preferirei il tuo approccio solo nel caso in cui searchQuerysia limitato alla ricerca all'interno di un'unica tabella, quindi non ci saranno join. In tal caso la mia funzione sarebbe simile a questa:

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

Quindi, so immediatamente che gli elementi dell'array sono in realtà i nomi di colonna di una particolare tabella che la classe che ha questo metodo rappresenta nel tuo codice.

Fai entrambe le cose. array_mergeconsente un elenco esplicito nella parte superiore della funzione, come piace al tuo collega, evitando che i parametri diventino ingombranti, come preferisci.

Consiglio anche vivamente di utilizzare il suggerimento di @ chiborg dai commenti alle domande - è molto più chiaro ciò che intendi.

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']);
    }
    ....
}

Inoltre potresti passare una stringa simile a una stringa di query e utilizzare parse_str(perché sembra che tu stia utilizzando PHP, ma altre soluzioni sono probabilmente disponibili in altre lingue) per elaborarlo in un array all'interno del metodo:

/**
 * 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 ...;
}

e chiamalo come

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

È possibile utilizzare http_build_queryper convertire da un array associativo a una stringa (il contrario che parse_strfa).