PHP5 classi suggerimenti

[Emulman]

e allora...ma si continuiamo! english lesson 3 by Mr. Brown....vediamo ora come definire i metodi di classe. Quando vogliamo creare un nuovo record in archivio dobbiamo 1) aprire il db 2) creare la query 3) controllare che sia stato tutto fatto correttamente 4) chiudere la query. Per gli esempio col db li faremo in MySQLi, versione ad oggetto della libreria standard MySQL che d'altronde è destinata a sparire nelle prossime versioni di PHP e aiuta nel comprendere la programmazione OOP. Quindi: inseriamo i dati del nuovo amico nel form e poi scriviamoli nelle variabili public che abbiamo definito all'inizio della classe amico:

require_once ('class/tantaRoba.php'); 
require_once('class/amico.php'); 
$amico = new Amico();

$amico->nome = $_POST['nome'];
$amico->cognome = $_POST['cognome'];
// ecc ecc
$amico->info = $_POST['info']; 

prima di tutto definisco il metodo salva della classe Amicoche definisce la query e dove i campi vengono scritti solo se contengono qualcosa:

public function salva() {
  $sql = "INSERT INTO amici(";
  if ($this->nome) $sql .= "nome";
  if ($this->cognome) $sql .= ", cognome";
  // ecc ecc
  if ($this->info) $sql .= ", info";
  $sql .= ") VALUES (";
  if ($this->nome) $sql .= "'" . $this->nome . "'";
  if ($this->cognome) $sql .= "'" . $this->cognome . "'";
  // ecc ecc
  if ($this->info) $sql .= "'" . $this->info . "'";
  $sql .= ")";
  return $this->executeQuery($sql);
} 

questo metodo definsice la query e come vedi restituisce..il valore di ritorno del metodo executeQuery! perchè? gaurda come è strutturata executeQuery sotot la classe TantaRoba:

public function executeQuery($query) {
  $mysqli = $this->openDB();
  if ($mysqli) {
    $result = $mysqli->query($query);
    if ($result) {
      return $mysqli->last_insert_id;
    else
      return 0;
    }
  }
  $this->closeDB($mysqli);
}

public function openDB() {
  $mysqli = new mysqli('localhost', 'user', 'password', 'database');
  if ($mysqli)
    return $mysqli;
  else
    return 0;
}

public function closeDB($mysqli) {
  $mysqli->close();
} 

le funzioni openDB e closeDB sono facili da capire. L'unica da spiegare è executeQuery: usa $mysqli->query($sql) per fare la query di inserimento e poi la funzione restituisce un valore $mysqli->insert_last_id : una operazione INSERT INTO aumenta di uno il contatore del cmapo principale di autoincremento, e questa istruzione restituisce appunto l'ultimo valore libero disponibile per il record, altrimenti restituisce FALSE. Se quindi la function executeQuery restituisce un valore superiore a zero allora l'inserimento è stato effettuato con successo. quindi in pratica la function SALVA fa tutto da sola, tu devi solo scrivere il codice seguente epr salvare un record:

require_once ('class/tantaRoba.php'); 
require_once('class/amico.php'); 
$amico = new Amico();

$amico->nome = $_POST['nome'];
$amico->cognome = $_POST['cognome'];
// ecc ecc
$amico->info = $_POST['info'];

if ($amico->salva())
  echo '<script>alert("Record inserito in archivio!")</script>';
else
  echo '<script>alert("Errore nel salvataggio del record!")</script>'; 

il tutto come vedi con pochissime righe senza che tu devi preoccuparti di come è strutturata la classe: te puoi solo migliorala se vedi che puoi.

FINE TERZA LEZIONE

[ciro78]

molti hanno consigliato di studiare framework per iniziare a lavorare in oop.

ma la oop esiste da prima dei framework.

i pattern aiutano ma non sono essenziali per comprendere come funziona una classe e tutto ciò che gira sulla programmazione ad oggetti. insomma...lo avete un pochino massacrato

[ilsangue]

Mi hai levato parecchi dubbi, che ritenevo ormai antichi

Un chiarimento forse stupido: la funzione executeQuery() è adatta, in questo caso, a sole query di tipo INSERT INTO, qualsiasi esse siano (da quel che ho capito salva() definita in amico, è UNA delle possibili relazioni che può sfruttare executeQuery()); perciò se volessi altre azioni, dovrei creare un nuovo metodo, dunque una nuova funzione... Giusto?

Quindi se ho capito giusto, potrei organizzare l'archittettura della mia ipotetica applicazione così:

tantaRoba diventa un elenco di azioni che riguardano strettamente il db: INSERT, UPDATE, DELETE, ecc. ecc.

Amico diventa invece un model; uno dei possibili che può sfruttare le azioni definite in tantaRoba, contenente le query dedicate al recupero dei dati.

Potrei inoltre estendere Amico in un controller così da manipolare i dati estratti dal model. Questo controller però sarà in stretta relazione ad Amico, e per cascata a tantaRoba.

Affiderei poi ad una view le istanze.

Ci sono?


Altro chiarimento: mi pare che il debugging, con gli oggetti, sia più difficile... Nel senso che mi accorgo se qualcosa è andato storto solo nella view finale, senza riuscire a risalire velocemente alla fonte dell'errore. Forse tutto sta nel fare i giusti controlli nella funzione?

[dex01]

Ciao Emulman, prima di tutto rinnovo i complimenti e i rigraziamenti per la tua disponibilità nello spiegarci (vedo che non solo l'unico) le linee guida della programmazione ad OOP, poi avrei una domanda da farti che riguarda esclusivamente il codice che mi hai postato ieri come esempio.
Ho fatto la stessa cosa utilizzando direttive mysql e non ho avuto problemi mentre se uso mysqli ottengo il seguente errore "Fatal error: Call to a member function assoc() on a non-object in ...\class\conndb.class.php on line 21"

class ConnectDB {
	public $host;
  	public $user;
  	public $password;
  	public $db;

function __construct() {
    $this->host = 'localhost';
    $this->user = 'root';
    $this->password = '';
    $this->db = 'prova';
}

public function arrayRecord($sql) {
     $mysqli = new mysqli($this->host, $this->user, $this->password, $this->db);
     if ($mysqli) {
       $res = $mysqli->query($sql);
       if ($res) {
         while ($row = $res->fetch->assoc())
             $array[] = $row;
       } else echo '<script type="text/javascript">alert("Errore nella query")</script>';
     } else echo '<script type="text/javascript">alert("Errore nella connessione al DB")</script>';
       $mysqli->close();
       return $array;
  }
}

class SelectQ extends ConnectDB {

public function ShowMarca() {
      $array = $this->arrayRecord("SELECT * FROM marca");
      if (count($array)) {
        foreach ($rows as $row)
          echo $row['id_marca'] . '
';
      }
  }


}

Sinceramente non riesco a capire per quale motivo restituisca l'errore.
Grazie

[Al_katraz984]

Originariamente inviato da Emulman

ma allora viene da dire: se la classe "TantaRoba" si occupa di tutta la gestione del database, come faccio a gestire i record generati dalla classe "Amico"? semplice (oddio...) la cosa migliore è quella di far ereditare da Amico tutti i i metodi e le proprietà di TantaRoba nel modo seguente:

class Amico extends TantaRoba {
//ecc ecc
} 

Buongiorno..

La classe Amico e la classe TantaRoba (che sembra essere un db) non hanno niente in comune tra di loro.. Quindi non è vero che l'associazione tra le due è "is-a". Non credo che la soluzione migliore sia "extends"

Si può dire che la classe Amico usa i metodi della classe TantaRoba, ora rimane solo da decidere se si tratta di composizione o aggregazione.

[Emulman]

Al_katraz984 - se trovi un metodo migliore di questo e soprttutto più semplice di extends per far comunicare due classi mettilo qua no?

Dex01 - sei sicuro che nel file PHP.INI sia attivata la libreria mysqli.dll ? (nella sezione extensions)

ilSangue - si giusto. executeQuery è solo uno dei tanti metodi che ti possono venire in mente , tutti con l'obiettivo di facilitare la vita al programmatore che non si deve preoccpuare di come è fatta la classe, ma deve solo pensare ad utilizzarla. Se poi scopri che c'è un modo ad esempio epr accelerare l'esecuzione di una query del 50% fallo pure....per il tuo pensiero vedo orientato al MVC piuù o meno è giusto il ragionamento..tantaRoba deve gestire tutto quello che non è di esclusiva pertinenza di Amico..potresti cmq utilizzare come faccio anche io di uan classe HTML che ti crea tramite metodi i tag HTML coi parametir che vuoi, ad esempio per un select

require_once 'class/html.php';
$html = new HTML();
$html->select($array, $name, $size, $tab, $onchange); 

con cui scrivo in un form un tag select riempito coi valorid ell'array array , di nome $nome, con tabindex pari a $tab e cosa succede se clicco su un valore con $onchange

Pian piano così come dicono anche altri ci si crea un proprio framework che si puiò riutilizzare in qualsiasi altra web application senza toccare in alcun modo la classe e accelrando quindi i tempi di sviluppo e di testing.

[Al_katraz984]

Originariamente inviato da Emulman
Al_katraz984 - se trovi un metodo migliore di questo e soprttutto più semplice di extends per far comunicare due classi mettilo qua no?

Certo volentieri, non si tratta di un metodo più semplice. E' il metodo più giusto.

Come ho detto prima le due classi non hanno niente in comune quindi estendere una classe Amico da un database per quanto possa essere semplice non è assolutamente OOP.

Il modo di associazione delle due classi è che Amico usa il database per alcune funzioni ma le due classi non hanno niente in comune. Si chiama Aggregazione e le due classi possono esistere indipendentemente l'una dall'altra.

class TantaRoba {

// ------

}

class Amico {

  private $tr;

  public function __construct( TantaRoba $tr ) {
    $this->tr = $tr;
  }
} 

ah si, l'utilizzo:

require_once( "TantaRoba.class.php" );
require_once( "Amico.class.php" );

$db = new TantaRoba();
$a = new Amico( $db ); 

[Emulman]

questo si che è un post intelligente, mica per denigrarti anzi....così si scambiano idee per far migliorare le nostre conoscenze e di tutti! almeno ognuno si fa una idea di come utilzizare al meglio la programmazione OOP..come vedi, io prediligo un modo, c'è chi ne predilige altri..basta che l'utente sappia capire cosa è meglio per lui!

per me meglio EXTENDS perchè introduce qualcosa che da tempo esiste in questo campo , appunto l'ereditarietà...la classe Amico eredita tutti i metodi e le proprietà di TantaRoba..tu invece mantinei indipendenti le classi utilizzando quella che per me è uan "forzatura"..non dico che sia peggio della mia tutt'altro, ma mi sa che non rende molto l'idea di comunicazione fra due classi...

[satifal]

Originariamente inviato da Emulman
per me meglio EXTENDS perchè introduce qualcosa che da tempo esiste in questo campo , appunto l'ereditarietà...la classe Amico eredita tutti i metodi e le proprietà di TantaRoba..tu invece mantinei indipendenti le classi utilizzando quella che per me è uan "forzatura"..non dico che sia peggio della mia tutt'altro, ma mi sa che non rende molto l'idea di comunicazione fra due classi...

Nonostante entrambe le soluzioni funzionino concordo con Al_katraz984.
Affrontando il problema dal punti di vista del paradigma OOP le classi Amico e TantaRoba non hanno nulla in comune tra loro. Una cosa è ereditare dei comportamenti un'altra è utilizzare semplicemente dei metodi. In fondo il termine stesso "eredità", concetto implementato tramite l'estensione, è più che esplicativo.
Una classe Autovettura o Motociclo ereditano (estendono) da Veicolo il che è logicamente corretto, invece una classe che "semplicemente" utilizza dei metodi di utilità non eredita da una ipotetica classe che espone tali metodi, ma la istanzia oppure ne riceve un'istanza.

[Al_katraz984]

Originariamente inviato da Emulman
per me meglio EXTENDS perchè introduce qualcosa che da tempo esiste in questo campo , appunto l'ereditarietà...la classe Amico eredita tutti i metodi e le proprietà di TantaRoba..tu invece mantinei indipendenti le classi utilizzando quella che per me è uan "forzatura"..non dico che sia peggio della mia tutt'altro, ma mi sa che non rende molto l'idea di comunicazione fra due classi...

Aspè.. Inheritance, aggregation e composition sono dei capisaldi dell programmazione OOP ed esistono tutti e 3 da quando esiste l'OO....

Associare una classe Amico ad una classe database per ereditarietà significa che l'analisi fatta a monte è sbagliata. E' come dire che tu sei una lampada:

class lampada {

  public funciton accendi() {
  }
}

class emulman extends lampione {

  // quindi emulman si può accendere....! 
  // No non è vero che tu ti accendi!!
  // la lampada si accende e tu la puoi accendere
} 

se tu vuoi accendere a lampada intanto dovrai avere a disposizione un'istanza della lampada e poi premi l'interrutore per accenderla:

class lampada {

  public funciton accendi() {
  }
}

class emulman {

  public function __construct( lampada $l ) {
    // ti rendo disponibile la lampada
    $this->l = $l;
  }

  public function luce() {
    // e luce FU!
    $this->l->accendi();
  }
}

/******************************/
$lamp = new lampada();
$tu = new emulman($lamp);

$tu->luce(); 

con l'analisi testuale delle parole si può capire facilmente le varie associazioni tra classi