POST dentro __construct

[_debo]

No, è meglio se opti per la soluzione con il metodo di login pubblico richiamato successivamente.

Una cosa molto importante visto che sei il secondo oggi che vedo scrivere sta cosa:

$_POST['nickname'] = isset($_POST['nickname']) ? $_POST['nickname'] : ""; 
$_POST['password'] = isset($_POST['password']) ? $_POST['password'] : ""; 

questa cosa NON si fa

$nickname = isset($_POST['nickname']) ? $_POST['nickname'] : null; 
$password = isset($_POST['password']) ? $_POST['password'] : null; 

[torrone]

Originariamente inviato da _debo
No, è meglio se opti per la soluzione con il metodo di login pubblico richiamato successivamente.

Una cosa molto importante visto che sei il secondo oggi che vedo scrivere sta cosa:

$_POST['nickname'] = isset($_POST['nickname']) ? $_POST['nickname'] : ""; 
$_POST['password'] = isset($_POST['password']) ? $_POST['password'] : ""; 

questa cosa NON si fa

$nickname = isset($_POST['nickname']) ? $_POST['nickname'] : null; 
$password = isset($_POST['password']) ? $_POST['password'] : null; 

grazie mille per la dritta

solo un'altra curiosità:

perchè è meglio adottare il metodo login pubblico e richaimarlo successivamente invece di farlo richiamare dal costruttore?

[Virus_101]

UHmpf io eviteri una cosa del genere ....


quqndo lavori con le classi devi capire bene anche lo "scoping" e che tale classe possa essere riutilizzata. quindi DEVI delegare al chimante l'intercettazione del dato in post, stiparlo in var e passarlo come paramentro al costruttore o al metodo della tua classe.

Avrai cosi' una classe completamente riutilzzaile in ogni contesto deciderai di usarla


file fooClass.php

class fooClass
{
       private $name ;
       private $surname ;

       public function __construct( $name , $surname )
       {
              $this->name = $name ; 
              $this->surname = $surname ;

       }
} 

file chiamante test.php:

include(CLASSPATH."/fooClass.php") ;

$foo = new fooClass($_POST["name"],$_POST["surname"]) ;

echo "<pre>" ;
var_dump($foo) ;
echo "</pre>" 

Come vedi .... e' 1 attimo

[satifal]

Originariamente inviato da Virus_101
UHmpf io eviteri una cosa del genere ....


quqndo lavori con le classi devi capire bene anche lo "scoping" e che tale classe possa essere riutilizzata. quindi DEVI delegare al chimante l'intercettazione del dato in post, stiparlo in var e passarlo come paramentro al costruttore o al metodo della tua classe.

Avrai cosi' una classe completamente riutilzzaile in ogni contesto deciderai di usarla


file fooClass.php

class fooClass
{
       private $name ;
       private $surname ;

       public function __construct( $name , $surname )
       {
              $this->name = $name ; 
              $this->surname = $surname ;

       }
} 

Finalmente del codice decente o quantomeno degno del paradigma OOP

[Plopper]

Originariamente inviato da Virus_101
UHmpf io eviteri una cosa del genere ....


quqndo lavori con le classi devi capire bene anche lo "scoping" e che tale classe possa essere riutilizzata. quindi DEVI delegare al chimante l'intercettazione del dato in post, stiparlo in var e passarlo come paramentro al costruttore o al metodo della tua classe.

Avrai cosi' una classe completamente riutilzzaile in ogni contesto deciderai di usarla


file fooClass.php

class fooClass
{
       private $name ;
       private $surname ;

       public function __construct( $name , $surname )
       {
              $this->name = $name ; 
              $this->surname = $surname ;

       }
} 

file chiamante test.php:

include(CLASSPATH."/fooClass.php") ;

$foo = new fooClass($_POST["name"],$_POST["surname"]) ;

echo "<pre>" ;
var_dump($foo) ;
echo "</pre>" 

Come vedi .... e' 1 attimo

E' un ottimo metodo cosi la si puo riutilizzare quando si vuole

[Virus_101]

Diciamo che piu' che un metodo e' la base della OOP

Inizi con classi di questo tipo e poi finisce a fare interfacce e factory

Cmq e' un esempio di classe std che appunto puoi includere instanziare e ritulizzare ove ti serva...
puoi nel case estenderla e usare un apporccio

1- faccio la classe base con i metodi di base
2- se dovee servirmi di piu' in un altro sistema creo una classe

class advancedFooClass extends fooClass
{


// USA super constructor altrimenti ridefiuniscilo

// aggiungi i metodi che ti servono


} 

[_debo]

@Virus and Satifal:

Faccio l'avvocato del diavolo e dico che la soluzione di virus per essere degna del paradigma OOP come dite non dovrebbe usare il costruttore della classe per settare gli attributi dell'oggetto ma avere appositi metodi che ne gestiscano la validazione e la sanificazione. La cosa ideale sarebbe sarebbe creare una classe che si occupi di gestire le request e di fornire i dati strettamente necessari e sanificati, login si occuperà poi di validare tali dati.

Altro nota importante composition over inheritance per applicare il concetto di delegation. Usare astrazione crea dipendenze interne al sistema che a lungo andare possono generare complessità nel codice. Prediligere sempre l'utilizzo di interfacce alle classi astratte anche perché mentre una classe può estendere una sola classe può al contrario implementare più interfacce.

[Virus_101]

si vero, ma da qualche parte bisogna pur cominciare no ?

diciamo che sarebbe statio oiu'0 corretto fare cosi'

class fooClass
{
       private $name ;
       private $surname ;

       public function __construct( $name , $surname )
       {
              try{
                     $this->setName($name) ;
                     $this->setSurname($surname) ;
              }
              catch( Exception $e ){ throw $e ; }

       }

       // GETTERS AND SETTERS
       public function getName()
       { return $this->name ; }
       public function getSurname()
       { return $this->surname ; }

       public function setName($name)
       { 
              // CODICE DI CONTROLLO E SE RILEVATO ERRORE 
              // genera eccezione 
       }

       public function setSurname($surname)
       { 
              // CODICE DI CONTROLLO E SE RILEVATO ERRORE 
              // genera eccezione 
       }

       // ALTRI METODI PUBBLICI O PRIVATI O PROTECTED che siano

} 

E siamo gia' qualche passo avanti.
debo conordo pienamente con te riguardo l'estensione delle classi e l'utilizzo di interfacce ma finche il progetto non e' grande. interfacce e factory servono un sacco invece quando i discorsi si complicano

[_debo]

Così mi piace di più.

Sul resto non è la dimensione che fa la differenza ma il ciclo di vita del software. Questa specifica funzionalità ha buone probabilità di cambiare in futuro? Si? Allora la progetto come si deve.

[Virus_101]