Convalida del __construct, assicurandosi Vars di di tipo corretto

Question

scrivere il mio primo classe PHP reale e sono imbattuto in un problema, il seguente è il mio metodo __construct:

public function __construct($foo,$bar) { 
     $this->foo = $foo; 
     $this->bar = $bar; 
} 

Sia $foo e $bar sono tenuti, senza di loro, i metodi falliranno e daranno errori php. Va bene quando non vengono definiti quando l'oggetto viene istanziato:

$var = new Class(); 

come questo vi darà un errore (ad esempio Classe richiede 2 params, nessuno set). Ma se sono impostate, ma non del corretto tipo di dati in questo modo:

$var = new Class('33','ddd'); 

I miei metodi verranno comunque provare a correre con le variabili sbagliate, e quindi stampare gli errori.

Qual è la procedura migliore per convalidare questi? Nel costrutto o in ogni metodo?

La mia soluzione che sto usando in questo momento funziona, ma non sono sicuro se è il modo 'corretto':

//$foo needs to be a string with letters only 
//$bar needs to be an integer 
public function __construct($foo,$bar) { 
     $this->foo = $foo; 
     $this->bar = $bar; 
     if(!is_numeric($bar)){ 
     //print error msg 
     } 
     elseif(other validation case) 
     etc... 
} 

I concetti di programmazione OO sono abbastanza nuovo per me, così i collegamenti a qualsiasi materiale di riferimento che hai usato sarebbe molto apprezzato.

Answer 1

probabilmente sarei fare qualcosa di simile per evitare l'ingombro all'interno del ctor e per permettere alla classe di impostare loro valori internamente:

class MyClass … 

    protected $_foo; 

    /** 
    * @param String $foo String with letters only 
    * @param Integer $bar Any Integer 
    * @return void 
    * @throws InvalidArgumentException when $foo is not letters only 
    * @throws InvalidArgumentException when $bar is not an Integer 
    */ 
    public function __construct($foo, $bar) 
    { 
     $this->_setFoo($foo); 
     $this->_setBar($bar) 
    } 

    /** 
    * @param String $foo String with letters only 
    * @return void 
    * @throws InvalidArgumentException when String is not letters only 
    */ 
    protected function _setFoo($foo) 
    { 
     if (FALSE === $this->_consistsOfLettersOnly($foo)) { 
      throw new InvalidArgumentException(
       '$foo should consists of letters only' 
      ); 
     } 
     $this->_foo = $foo; 
    } 

    … 

Questo ha il vantaggio che se avete bisogno di esporre pubblicamente il setter in seguito, devi solo modificare la parola chiave di visibilità.

Effettuare la convalida nel proprio metodo non è strettamente necessario, ma penso che renda il codice più leggibile. Se trovi che un'altra proprietà in quella classe ha bisogno della stessa validazione, puoi anche riutilizzarla più facilmente.

Answer 2

La convalida dei tipi nel costruttore (come nel tuo esempio) mi sembra la scelta logica, anche se è un po 'strano se gli argomenti sono facoltativi. Probabilmente si dovrebbe impostare i valori predefiniti sicuri se questo è caso via ...

public function __construct($foo=null, $bar=null)

Detto questo, è possibile utilizzare type hinting per gli argomenti in PHP, ma credo che questo funziona solo per gli array e le classi. (Non è una sorpresa, in PHP non esiste un numero intero o stringa.)

Come altri hanno già detto, dovresti anche assicurarti di eseguire la convalida in qualsiasi setter che hai o (meglio ancora) semplicemente chiamare i setter dall'interno del costruttore per garantire che non ci sia alcuna duplicazione del codice.

Answer 3

Se sono richiesti $ foo e $ bar, convalidarli in __construct è il posto migliore per farlo (in caso contrario: utilizzare un setter e convalidare lì). Se lo fai in ogni metodo, ti ritroverai con il codice duplicato. Immagina se un tipo di dati cambia, dovresti cambiare ogni metodo ...

Se ti piace essere davvero schizzinoso, puoi chiamare is_numeric prima di assegnare $ bar a $ this-> bar in quanto l'assegnazione non è necessaria se il controllo di un valore numerico non riesce.

Answer 4

Il modo migliore è quello di utilizzare getter e setter - ad esempio:

private $_foo; 
private $_bar; 

public function __construct($foo,$bar) { 
    $this->setFoo($foo); 
    $this->setBar($bar); 
} 

public function setFoo($foo) { 
    // validate here 

    $this->_foo = $foo; 
} 

public function getFoo() { 
    return $this->_foo; 
} 

... 

Molto più pulito in questo modo ...

Answer 5

I suoi problemi non sono derivante dal fatto che si sta scrivendo orientato agli oggetti codice - è perché PHP è un loosely typed language. Ciò significa che le variabili possono contenere qualsiasi tipo di dati, da int a Object. È possibile applicare un certo tipo di tipo di colata in questo modo:

$foo = (int)$foo; 
$bar = (str)$bar; 

Answer 6

Elaborando un po 'la risposta di @ xil3 direi tutta Dan era alla ricerca di/esigenze è:

private $_foo; 
private $_bar; 

public function __construct($foo,$bar) { 
    if(is_int($foo)) { 
    $this->setFoo($foo); 
    } 
    if(is_string($bar)) { 
    $this->setBar($bar); 
    } 
} 

public function setFoo(int $foo) { 
    $this->_foo = $foo; 
} 

public function setBar(string $bar) { 
    $this->_foo = $bar; 
} 

... 

permettendo al suo oggetto da istanziato senza parametri senza il fatale, con vincoli di tipo sui setter.

Answer 7

Non si dovrebbe fare altro che impostare valori nel costruttore. Se avete bisogno di validare parametri del costruttore a quella setter (possibilmente privati), o utilizzare gli argomenti di tipo particolare, in modo da PHP convaliderà tipo per voi, per esempio:

__construct(SomeType $foo, AnotherType $bar); 

Per esempio è possibile utilizzare i tipi di dati SPL:

__construct(SplInt $integer, SplString $string); 

Read more about SPL data types