Quanti controlli di variabili dovresti fare?

Question

Qualcosa di cui non sono mai stato sicuro è quanti controlli variabili fare in PHP. Ad esempio, prendi la seguente parte di codice. Non sto controllando nessuna delle variabili prima di assegnarli o passarli ad una funzione per vedere se contengono ciò che mi aspetto

$carId = '12'; 
$aCar = fetchCar($carId); 

$make = $aCar['make']; 
$model = $aCar['model']; 
$yearMade = $aCar['year']; 
$age = calcAge($yearMade); 

Ora, se aggiungo alcuni controlli

$carId = '12'; 

if(is_numeric($carId)) 
{ 
    $aCar = fetchCar($carId); 

    if(isset($aCar['make']) && is_string($aCar['make'])) 
    { 
     $make = $aCar['make']; 
    } 
    else 
    { 
     //Report error 
    } 

    if(isset($aCar['model']) && is_string($aCar['model'])) 
    { 
     $model = $aCar['model']; 
    } 
    else 
    { 
     //Report error 
    } 

    if(isset($aCar['year']) && is_numeric($aCar['year'])) 
    { 
     $yearMade = $aCar['year']; 
     $age = calcAge($yearMade); 
    } 
    else 
    { 
     //Report error 
    } 
} 
else 
{ 
    //Report errors 
} 

Il codice è ora meglio ma è un po 'eccessivo e gonfio? Dovrei fare questo molti controlli?

Se non dovessi fare questo, molti controlli dove traccia la linea tra ciò che dovresti e non dovresti controllare?

Answer 1

Questo è il dilemma di un linguaggio di tipo dinamico. Dipende molto dalla funzione di fetchCar().

L'approccio che vorrei assumere è che fetchCar restituisca un array di vetture o un'eccezione di lancio. Se si combina questo con una buona logica di gestione delle eccezioni si può finire con un codice pulito e stabile.

Ad esempio:

function fetchCar($id) { 

    $car = queryDatabaseSomehow(); 
    if (empty($car)) { 
     throw new ExceptionNotFound(); 
    } 
    //eventually you can put your type checking here? 
    if (!isset($car['x']) || !is_string($car['x'])) { 
     throw new ExceptionDb(); 
    } 
} 

echo fetchCar(3)['make']; 

Inoltre, se si desidera fare questo super-corretto e andare completamente OOP, auto dovrebbe diventare una classe con marca, modello e anno come i suoi membri. fetchCar() restituirebbe Car o lanciare Exception. Ma questo non è sempre auspicabile, naturalmente.

Answer 2

Io invece trasformo tutto in una funzione che può essere riutilizzata per questi casi.

function check_keys($arr_check, $arr_cond) { 

    $boo_success = TRUE; 
    foreach(array_keys($arr_cond) as $h) 
     if (in_array($arr_cond[$h], array('is_string', 'is_numeric'))) { 
      if (! isset($arr_check[$h]) or ! ($arr_cond[$h]($arr_check[$h]))) { 

       $boo_success = FALSE; 
       echo "The key {$h} is missing!"; 
       // If run through a class, $this->errors[] = 'error message'; 

      } 
     } else { 

      $boo_success = FALSE; 
      echo 'Invalid function'; 

     } 

    return $boo_success; 

} 

$arr_keys = array('make' => 'is_string', 
        'model' => 'is_string', 
        'year' => 'is_numeric'); 

if (check_keys($aCar, $arr_keys)) { 

    // Run successful stuff 

} 

Answer 3

Un problema che alcune persone non hanno notato. Diffidare di utilizzare is_string:

<?php 
$var = "test"; 
$var['something'] = 2; 

if(is_string($var['something'])) { 
    echo "Hello world!"; // Will echo this because $var is a string! 

} else { 
    echo "Hello hell!"; 
} 
echo "<br/>"; 
echo $var['something']; // returns 2 
?> 

PHPFiddle.

confrontarla con questa:

$var = array('something' => 2); 

if(is_string($var['something'])) { 
    echo "Hello world!"; // $var is now an array 

} else if (is_numeric($var['something'])) { 
    echo "Hello hell!"; // Will echo this because $var is string! 
} 
echo "<br/>"; 
echo $var['something']; 

È necessario verificare se $var è un array, in quanto potrebbe dare risultati inaspettati. isset($var['something']) restituirà true nel primo esempio.

Per rispondere alla tua domanda, non penso che siano troppi controlli. Dipende davvero da cosa fa fetchCar() e come ottiene i dati. Se non ci si può fidare (ad esempio, si basa sui dati dell'utente), è necessario eseguire tutti questi controlli. Se no, allora non ha senso davvero.