Chiarimenti sulle interfaccie

Bene dopo tante letture ho iniziato a mettermi a lavoro in proprio, sperimentando la programmazione ad oggetti. Prendendo spunto da un tutrial di cui ho letto soltanto il titolo e l'interfaccia, ho deciso di crearmi un'interfaccia per la gestione del collegamento al database, e la cosa belle e' che seguendo questa interfaccia potrei usare gli stessi metodi con i diversi database.

Allora la struttura dell'interfaccia sara':

interface database
{
        public function connect($var1, $var2, $var3, $var4);   public function error(); 
        public function errno(); 
        public static function escape_string($string); 
        public function query($query); 
        public function fetch_array($result); 
        public function fetch_row($result); 
        public function fetch_assoc($result); 
        public function fetch_object($result); 
        public function num_rows($result); 
        public function close();
}

E di seguito leggerete la classe che utilizza questa interfaccia:

include_once("database.interface.php");
class MySQL implements database 
{
   //Creo una variabile protetta che mi consenta di tener traccia della connessione
   public $link;
   //e adesso una variabile che mi consenta di mantenere i risultati della connessione per operarci successivamente
   public $result;
   //Creo il costruttore
   public function __construct()
   {
      $this->link = '';
      $this->result =  '';
   }
   //La funzione o meglio il metodo che ci consentira' di connettersi ad un database
   public function connect($dbHost, $dbUser, $dbPsw, $dbName)
   {
      //Immagazzino il link della connessione a questa variabile
      $this->link = mysql_connect($dbHost, $dbUser, $dbPsw);
      //Effetto il controllo per vedere se e' stata avviata la connessione in modo corretto
         if (!$this->link)
            throw new Exception("Connessione al database non riuscita: ".mysql_error()."<br />");
      $this->result = mysql_select_db($dbName, $link);
         if(!$this->result)
            throw new Excempion("Selezione del database non riuscita: ".mysql_error()." <br />");
   }
   public function error()
   {
      //Qui terro' i messaggi di errore da vedere poi come implementarla...
   }
    public function errno()
    {
       //Il valore numerico dell'errore
    }
    public static function escape_string($string)
    {
       //Controllo i caratteri speciali nella stringa inserita
    }
    public function query($query)
    {
       //Invio la query al database
    }
    public function fetch_array($result)
    {
       //Scorro il risultato come un array
    }
    public function fetch_row($result)
    {
       //Ritiro la riga del risultato
    }
    public function fetch_assoc($result)
    {
       //Il risultato sara' considerato come un array associativo
    }
    public function fetch_object($result)
    {
       //Il risultato sara' considerato come un oggetto
    }
    public function num_rows($result)
    {
       //Controllo il numero di righe
    }
    public function close()
    {
       //Chiudo la connessione al database
    }

}

Okay adesso che ho descritto la situazzione passo a mostrarvi l'utilizzo semplice semplice per la classe che ho da poco creato...

include_once("mysql.class.php");
   include_once("conf.inc.php");
   try
   {
      $connessione = new MySQL($dbHost, $dbUser, $dbPsw, $dbName);
   } 
   catch (Exception $e)
   {
      echo "Eccezione: ".$e->getMessage();
   }

Ora che vi ho portato per manina vi spiego il mio dubbio, leggendo sul sito la parte inerente alle interfaccie viene detto che per le classi che implementano l'interfaccia devono avere dei metodi che accettano almeno il numero di parametri accettati dal metodo definito dall'interfaccia. Questo, a quanto l'ho capita io vuol dire che se ci sono un numero maggiore di parametri rispetto al metodo definito nell'interfaccia non si dovrebbe incorrere in alcun errore...

Invece a me succede questo:

Fatal error: Declaration of MySQL::connect() must be compatible with that of database::connect() in /Volumes/Pr0v4/htdocs/progetto_mio/mysql.class.php on line 4

Vi ringrazio in anticipo per l'aiuto che certamente mi darete!!

inviato 9 anni fa
Pr0v4
modificato 9 anni fa
X 0 X

Il sito dove hai letto quella roba, se così c'è scritto, ha detto una stupidata.

Un'interfaccia serve proprio a "passare" i metodi della classe, così come sono, anzi, se modifichi il metodo poi devi modificare anche l'interfaccia e questo è un limite bello e buono per la manutenibilità del codice.

Ah la tua classe ha almeno un difetto: quando ti connetti al database lo apre persino.

Meglio se per quest'ultima funzione usi un metodo separato.

Un ultima cosa, ti consiglio di studiarti il pattern singleton per creare una classe che si connette ad un database.

Il singleton viene richiamato una e una sola volta, così come l'hai implementato tu, il rischio è che si creino più implementazioni della tua classe, con danno. (non puoi aprire un database già aperto).

risposto 9 anni fa
Marco Grazia
X 0 X

Allora ho modificato la classe aggiungendo questo metodo:

//La funzione che mi permettera' di aprire il database
   public function open($dbName, $this->link)
   {
      $this->result = mysql_select_db($dbName, $this->link);
         if(!$this->result)
            throw new Exception("Selezione del database non riuscita: ".mysql_error()." <br />");
   }

Ma purtroppo mi restituisce questo errore:

Fatal error: Cannot re-assign $this in /Volumes/Pr0v4/htdocs/progetto_mio/mysql.class.php on line 31

Perche' mi parla di riassegnazione della variabile $this->link? io non sto assegnando niente, sto cercando soltanto di aprire il database...

Cmq una cosa, perdona la mia ignoranza ma sono soltanto agli inizi, perche' mi consigli di utilizzare un sigleton? Nel senso questo dovrebbe essere la base per un piccolo CMS che vorrei dilettarmi a costruire; ma se mi si connette un altro utente e ho dichiarato la classe che si connette al db come sigleton, che succede?

Grazie ancora!

risposto 9 anni fa
Pr0v4
X 0 X

Perché la passi dentro la chiamata del metodo?

Non puoi riassegnare dall'esterno $link dopo che l'hai già fatto in __construct()

il metodo corretto sarebbe dovuto essere:

   

public function open($dbName, $link) {
$this->link = $link;

eccetera

Il fatto che il CMS sia piccolo o grande non importa, ma importa quanti tentano di accedervi nello stesso tempo.

Mettiamo che due persone vi stanno gironzolando dentro e attivano la lettura del database, se questo è stato già aperto dal primo navigatore, il secondo rischia di riaprirlo mandando lo script in errore.

Invece dovresti fare in modo che una volta aperto il database non sia più possibile aprirlo se non dopo averlo chiuso.

risposto 9 anni fa
Marco Grazia
X 0 X

Aspetta un attimo, mi sto perdendo...

allora nel database ho tutti gli articoli che voglio tenere nel mio sito e consultabili, per quanto ho capito io mi stai dicendo che piu' di una persona alla volta non possono vedere il sito???

Quello che vorrei fare io, e' un sito con i testi basati su database, quindi anche chi si connette all'homepage si colleghera' al database, e occuperera' un posto... E oltre a lui in quell'istante nessuno mi pou' consultare il sito perche' il database e' impegnato?

dovrei aggiungere un mysql_close() ad ogni fine pagina no?

TPer favore aiutami a farmi chiarezza!

risposto 9 anni fa
Pr0v4
X 0 X

Essendo php un linquaggio interpretato e per il fatto che gira su un webserver ogni utente viene servito in maniera isolata dagli altri.

Per spiegarti meglio faccio un esempio banale :

Tizio entra nel sito, viene instanziata la classe del database e tutte le altre ( chiamate ) se ce ne sono.

Il programma usa l'istanza (unica, cioè in qualsiasi punto del codice il programma "può accedere" a quella parte di memoria che contiene l'istanza della classe singleton) e quindi puoi evitare di creare 1000 istanze della classe db (o altre) e di sprecare memoria.

Il codice finisce di essere eseguito, la richiesta è completa la memoria viene deallocata, avviene l'output dell'html sul tuo browser.

Ovviamente il programma finisce di essere eseguito al termine del caricamento.

La classe singleton ti permette di ottenere l'indirizzo della sua istanza tramite il metodo getInstance ( di solito ).

ex :

<?php
$db = miaclasseDatabase::getInstance();
$db->connect();
$db->query();

chiamando il costruttore della classe singleton ( che è privato ) otterresti un errore fatale del genere:

Fatal error: Call to private miaclasseDatabase::__construct() from invalid context in [...]db.php on line [...]

scusami nel caso avessi detto boiate;

 :bye:

risposto 9 anni fa
Andrea Turso
Andrea Turso
86
X 0 X

Sono ancora un pochetto perso nel mio...

Vorrei capire come mai non riesco ancora a far funzionare questa classe... Sicuramente sbaglio io!

Ho provato a rifare il metodo open, con qualche esperimento, ma mi da sempre questo errore:

Warning: mysql_select_db(): supplied argument is not a valid MySQL-Link resource in /Volumes/Pr0v4/htdocs/progetto_mio/mysql.class.php on line 34
Eccezione: Selezione del database non riuscita:

Ma vi stampo lo stesso il codice per farmi capire dove diavolo sto sbagliando!

public $link;
   //e adesso una variabile che mi consenta di mantenere i risultati della connessione per operarci successivamente
   public $result;
   //Creo il costruttore
   public function __construct()
   {
      $this->link = '';
      $this->result =  '';
   }
   //La funzione o meglio il metodo che ci consentira' di connettersi ad un database
   public function connect($dbHost, $dbUser, $dbPsw)
   {
      //Immagazzino il link della connessione a questa variabile
      $this->link = mysql_connect($dbHost, $dbUser, $dbPsw);
      //Effetto il controllo per vedere se e' stata avviata la connessione in modo corretto
         if (!$this->link)
            throw new Exception("Connessione al database non riuscita: ".mysql_error()."<br />");
   }
   //La funzione che mi permettera' di aprire il database
   public function open($dbName)
   {
      $id = $this->link;
      $risultato = mysql_select_db($dbName, $id);
         if(!$risultato)
            throw new Exception("Selezione del database non riuscita: ".mysql_error()." <br />");
      $this->result = $risultato;
   }

Ho incollato anche il costruttore e altro, per cercare di capire tutto insieme dove sto sbagliando...

risposto 9 anni fa
Pr0v4
X 0 X

Prova am mettere in mysql_select_db direttamente $this->link, senza passarlo ad $id

 :bye:

P.S.:Un'interfaccia serve proprio a "passare" i metodi della classe, così come sono, anzi, se modifichi il metodo poi devi modificare anche l'interfaccia e questo è un limite bello e buono per la manutenibilità del codice.

Non si tratta di un limite ma di una garanzia. Siccome nasce prima l'interfaccia e poi la classe è normale che questa debba rispettare la firma dei metodi dell'interfaccia e non il viceversa. Per la stessa ragione nell'evoluzione di una applicazione deve cambiare prima l'interfaccia e poi si deve adeguare la classe. L'interfaccia infatti è come un contratto che una classe decide di sottoscrivere. La classe si impegna a rispettarlo, per cui promette di implementare tutti i metodi previsti dall'interfaccia. La classe quindi non può permettersi di modificare le firme di questi metodi e a maggior ragione non può chiedere all'interfaccia di cambiare. Al contrario se cambia l'interfaccia (se cambia il contratto) tutte le classi che la implementano (tutte le classi che l'hanno sottoscritta) devono adeguarsi.

Se volete una dimostrazione dell'uso delle interfacce come "contratto" guardate questo esempio che fa uso del type hinting:

http://www.php.net/manual/en/language.oop5.typehinting.php#69369

risposto 9 anni fa
Gianni Tomasicchio
modificato 9 anni fa
X 0 X

Porcaccia...

Ancora ribadisce con lo stesso errore...

Scusatemi ma come si fa allora a passare una proprieta' di un oggetto, come in questo caso $link, ad un metodo dichiarato nella stessa classe???

Ho modificato cosi' il mio codice:

public function open($dbName)
   {
      $risultato = mysql_select_db($dbName, $this->link);
         if(!$risultato)
            throw new Exception("Selezione del database non riuscita: ".mysql_error()." <br />");
      $this->result = $risultato;
   }

Ma ancora nn ne vuol sapere di fare questa operazione che a mio parere dovrebbe essere semplice semplice!

Piu' che altro mi interesserebbe capire dove sia l'errore concettuale, in modo da non ripetere piu' un errore simile!

PS: ma come mai se provo a stampare $this->link nn mi restituisce niente???

risposto 9 anni fa
Pr0v4
modificato 9 anni fa
X 0 X

a me questa classe funziona correttamente:

<?php
class Mysql {
   public $link;

   public function connect($dbHost, $dbUser, $dbPsw)
   {
      $this->link = @mysql_connect($dbHost, $dbUser, $dbPsw);
      if (!$this->link) {
         throw new Exception("Connessione al database non riuscita: ".mysql_error()."<br />");
      } else {
         echo "connesso con successo\n";
      }
   }


   public function selectDb($dbName)
   {
      $risultato = @mysql_select_db($dbName, $this->link);
      if(!$risultato) {
         throw new Exception("Selezione del database non riuscita: ".mysql_error()." <br />");
      } else {
         echo "DB selezionato con successo\n";
      }
   }
}

$myDb = new Mysql();
$myDb->connect('localhost', 'root', 'secret');
$myDb->selectDb('test');
?>

 :bye:

risposto 9 anni fa
Gianni Tomasicchio
X 0 X

ciao :)

non ho letto tutta la discussione

però ti posso dire che è inutile utilizzare le interfacce così

una interfaccia non serve ad obbligare a definire i metodi di una classe

ma serve a definire un modello per far funzionare la classe nel contesto in cui è inserita

<?php

interface Obbligo
{public function pippo($args);}

class Test1 implements Obbligo
{public function pippo($args){echo("pippo bisogna definirlo per forza<br>");}}
class Test2 implements Obbligo
{public function pippo($args){echo("pippo bisogna definirlo per forza<br>");}}
class Test3 implements Obbligo
{public function pippo($args){echo("pippo bisogna definirlo per forza<br>");}}
class Test4
{public function __call($asd, $asd2){echo("qui pippo non è definito<br>");}}

class Principale
{
     public static function start($what, $args)
     {
          $what->pippo($args);
     }
}

$args="sasd";
Principale::start(new Test1(),$args);
Principale::start(new Test2(),$args);
Principale::start(new Test3(),$args);
Principale::start(new Test4(),$args);

?>

il test4 darà un errore perchè cercherà di accedere al metodo pippo che non esiste

le interfaces (come abstract, è esattamente la stessa cosa)

sono utili per facilitare (anche solo nella logica) la creazioni le classi che dovrebbero far parte di un contesto

ossia implementare un'interfaccia obbliga la classe ad interfacciarsi nel contesto in cui dovrebbe funzionare

:D

ciauz

risposto 9 anni fa
Wesley
X 0 X

è inutile utilizzare le interfacce così

una interfaccia non serve ad obbligare a definire i metodi di una classe

ma serve a definire un modello per far funzionare la classe nel contesto in cui è inserita

le interfaces (come abstract, è esattamente la stessa cosa)

sono utili per facilitare (anche solo nella logica) la creazioni le classi che dovrebbero far parte di un contesto

ossia implementare un'interfaccia obbliga la classe ad interfacciarsi nel contesto in cui dovrebbe funzionare

Le due affermazioni mi sembrano un po' in contraddizione. Spiegati meglio.

E comunque un'interfaccia ha uno scopo diverso da un metodo o una classe abstract.

 :bye:

risposto 9 anni fa
Gianni Tomasicchio
X 0 X

Il fatto è che l'ho trovato scritto anche io che abstract è simile all'interfaccia, ma non è che una cavolata, sono due cose differenti, anche se la differenza può essere sottile.

Le classi astratte invece sono un sistema che permette di definire classi parzialmente completate che lasciano l'implementazione di alcuni metodi alle sottoclassi. Una classe astratta deve essere definita utilizzando la parola chiave abstract; lo stesso vale per quei metodi astratti della classe

http://php.html.it/guide/lezione/2604/le-classi-astratte/

In realtà, l'astrazione della classe non è l'interfaccia, ma solo la definizione della struttura, mentre l'interfaccia è, come dice la parola stessa, la parte che si interfaccia col mondo esterno.

E' una specie di metodo per nascondere l'implementazione, tu hai una scatola chiusa che fa qualcosa, ed è la classe, la quale tramite l'interfaccia esporta i modi per collegarsi ad essa.

Le classi astratte servono a definire la forma che la classe avrà, ma senza implementarne i metodi, che saranno implementati in una classe da essa derivata.

Gianni, quando ho detto che sono una seccatura, non volevo dire che sono inutili, ma solo che obbligano il programmatore a rivederle spesso se, costruendo la classe scopre che deve necessariamente implementare nuove funzionalità.

Le interfacce sono comode ma in fase di progettazione obbligano il programmatore a rivederle spesso.

risposto 9 anni fa
Marco Grazia
X 0 X

è inutile utilizzare le interfacce così

una interfaccia non serve ad obbligare a definire i metodi di una classe

ma serve a definire un modello per far funzionare la classe nel contesto in cui è inserita

le interfaces (come abstract, è esattamente la stessa cosa)

sono utili per facilitare (anche solo nella logica) la creazioni le classi che dovrebbero far parte di un contesto

ossia implementare un'interfaccia obbliga la classe ad interfacciarsi nel contesto in cui dovrebbe funzionare

Le due affermazioni mi sembrano un po' in contraddizione. Spiegati meglio.

E comunque un'interfaccia ha uno scopo diverso da un metodo o una classe abstract.

 :bye:

ustia e dire che mi sono impegnato!!  :D

marcolino secondo me fai un po' di confusione... tu stai parlando di API, io di interfacce nella programmazione ad oggetti

http://it.wikipedia.org/wiki/Interfaccia_%28informatica%29

http://it.wikipedia.org/wiki/Application_programming_interface

risposto 9 anni fa
Wesley
X 0 X

beh le interfacce non fanno altro che definire delle linee guida su come la classe dovrà essere utilizzata.

secondo me, basando il codice su delle interfacce permette di utilizzare il codice che si sta scrivendo come se fosse un'api.

Quindi (imho) quello che dice marcolino è corretto.

:bye:

risposto 9 anni fa
Andrea Turso
Andrea Turso
86
modificato 9 anni fa
X 0 X

Per aggiungere qualche altro spunto di riflessione sull'utilizzo delle interfacce e dei metodi atratti vi invito a pensare al loro utilizzo nei linguaggi ad oggetti fortemente tipizzati (es. il Java) in relazione al polimorfismo.

Partiamo dai metodi astratti. Dobbiamo realizzare un sistema che registra i versi degli animali di uno zoo. Avrò una classe Registratore con un metodo per registrare il verso:

[tt]void registra(Animale unAnimale); // notate la dichiarazione del tipo Animale [/tt]

Ogni razza presente nello zoo avrà una sua classe: Elefante, Giraffa, ecc. tutte estendono la classe Animale che ha un metodo astratto.

[tt]String emettiVerso();[/tt]

Il metodo è astratto poiché la classe Animale non sa cosa emettere ma è certa che tutti gli animali particolari sappiano (e debbano!!!) emettere un verso, altrimenti il registratore non funzionerebbe.

In questo contesto l'aver modellato le classi Elefante Giraffa come figlie di Animali fa si che queste possano essere passate al metodo registra della classe Registratore. Il metodo astratto vincola il progettista delle classi derivanti da Animale ad implementare emettiVerso().

In questo caso il metodo astratto deve essere pubblico altrimenti il registratore non potrebbe utilizzarlo, ma non ci sono vincoli in generale. Un metodo astratto può tranquillamente essere privato quindi invisibile al resto del mondo esterno.

Facciamo adesso un esempio di utilizzo delle interfacce. Il nostro Registratore deve memorizzare i versi catturati degli animali su un qualsiasi dispositivo di output. Sarà questo dispositivo a preoccuparsi della memorizzazione vera e propria su un particolare supporto. Supponiamo di voler creare 3 dispositivi: Stampate, HardDisk e Tape. Per modellarli correttamente dobbiamo risolvere 2 problemi: fare in modo che tutti e tre abbiamo un metodo attraverso il quale ricevere i dati provenienti dal registratore:

[tt]void salvaDati(String dati);[/tt]

ed inoltre è necessario poter passare al Registratore uno di questi tre oggetti indifferentemente, similmente a quanto fatto per il metodo registra(). La soluzione precedentemente adottata si basava sull'ereditarietà ed era corretta poiché Elefante e Giraffa sono indubbiamente 2 Animali. In questo caso però Stampate, HardDisk e Tape difficilmente possono essere ricondotti ad un unico tipo di oggetto padre. Magari saremmo tentati di creare un oggetto Dispositivo, padre di Stampate, HardDisk e Tape ma è evidente che la scelta è forzata. A pensarci bene in questo caso non abbiamo bisogno di indicare un oggetto che E' UN qualcosa ma che SA FARE qualcosa. Mentre prima avevamo bisogno di oggetti che sono degli animali, adesso abbiamo bisogno di oggetti che sono in grado di salvare dei dati. Per dui decidiamo di creare una interfaccia di nome Output che contenga il metodo salvaDati() e di creare 3 classi distinte Stampate, HardDisk e Tape che implementino questa interfaccia. A questo punto sappiamo come riscrivere il metodo registra() del registratore in modo che possa anche salvare i versi catturati:

[tt]void registra(Animale unAnimale, Output unDispositivo) {

   String verso = unAnimale.emettiVerso();   

   unDispositivo.salvaDati(verso);

}[/tt]

Il metodo registra accetta quindi come parametro un qualsiasi oggetto derivante da Animale e un qualsiasi oggetto che implementa l'interfaccia Output.

Si noti che una interfaccia può avere soltanto metodi pubblici (al contrario dei metodi astratti). Una classe che possiede un metodo astratto sembra dire: "so che è necessario fare una determinata cosa ma non so come farla". Si tratta quindi di una esigenza da risolvere all'interno della gerarchia di classi, qualcosa di privato da risolvere in casa.

L'interfaccia invece ha un utilizzo trasversale all'interno del modello delle classi. Essa pone vincoli a qualsiasi classe abbia intenzione di implementarla. Una classe che implementa una interfaccia può con orgoglio dire: "mi posso fregiare di implementare una determinata interfaccia poiché mi sono preso la briga di realizzare le relative funzionalità".

 :bye:

risposto 9 anni fa
Gianni Tomasicchio
X 0 X
Essa pone vincoli a qualsiasi classe abbia intenzione di implementarla. Una classe che implementa una interfaccia può con orgoglio dire: "mi posso fregiare di implementare una determinata interfaccia poiché mi sono preso la briga di realizzare le relative funzionalità".

è esattamente quello che volevo dire io

una interfaccia non è "la pianificazione del lavoro"

io ho creato un piccolo template engine per una intranet i cui widgets implementano tutti

<?php

interface Widgets

{

   public function getSource();

}

?>

semplicemente perchè quello è l'unico metodo che permette ai widget di lavorare correttamente nel loro contesto, ossia il template engine

le API imho sono tutt'altra cosa, spero che gianni spieghi anche questo perchè temo di non esserne in grado :D

risposto 9 anni fa
Wesley
X 0 X

Le API sono un'altra cosa...fanno anche il miele! Ma mi sa che siamo un po' OT.

 :bye:

risposto 9 anni fa
Gianni Tomasicchio
X 0 X
Le API sono un'altra cosa...fanno anche il miele!

:death:

risposto 9 anni fa
Andrea Turso
Andrea Turso
86
X 0 X

Scusate ragazzi se riporto il thread a discorsi un pochetto piu' da "novizio", ma non capisco perche' nonostante che stia funzionando tutto, ho provato, creandomi un metodo per il recupero della variabile di istanza (visto che e' private) di farmi restituire il link di connessione proprio come dice la guida su php.net:

Restituisce un identificativo di connessione MySQL in caso di successo oppure FALSE in caso di fallimento.

Ma invece non mi restituisce niente! Potreste spiegarmi perche' se provo a stampare il resurce id del risultato di una query questo viene stampato, mentre se provo a stampare quello di un collegamento nn me lo mostra?

Grazie ancora in anticipo, e anche per tutte le discussioni nate che mi stano aiutando a farmi chiarezza!

risposto 9 anni fa
Pr0v4
X 0 X

posta il codice :D

risposto 9 anni fa
Wesley
X 0 X

Hai ragione perdonami:

<?php

class MySQL
{
   //Creo una variabile protetta che mi consenta di tener traccia della connessione
   private $link;
   
   //La funzione o meglio il metodo che ci consentira' di connettersi ad un database
   public function connect($server ='', $username ='', $password ='', $new_link = true, $client_flags = 0)
   {
      //Immagazzino il link della connessione a questa variabile
      $this->link = mysql_connect($server, $username, $password, $new_link, $client_flags);
      //Effetto il controllo per vedere se e' stata avviata la connessione in modo corretto
         if (!$this->link)
            throw new Exception("Connessione al database non riuscita: ".mysql_error()."<br />");
   }
   //La funzione che mi permettera' di aprire il database
   public function open($nome_db)
   {
      $risultato = mysql_select_db($nome_db, $this->link);
         if(!$risultato)
            throw new Exception("Selezione del database non riuscita: ".mysql_error()." <br />");
      $this->result = $risultato;
   }
   //La funzione che restituira' l'errore, tramite la funzione mysql_error()
   public function error()
   {
      //Qui terro' i messaggi di errore da vedere poi come implementarla...
      return mysql_error($this->link);
   }
   //Restituisce il valore numerico del messaggio di errore della precedente operazione MySQL, tramite la funzione mysql_errno()
    public function errno()
    {
       //Il valore numerico dell'errore
       return mysql_errno($this->link);
    }

    public static function escape_string($string)
    {
       //Controllo i caratteri speciali nella stringa inserita
       return mysql_real_escape_string($string);
    }

    public function query($query)
    {
       //Invio la query al database
       return mysql_query($query, $this->link);
    }

    public function fetch_array($result)
    {
       //Scorro il risultato come un array
       return mysql_fetch_array($result);
    }

    public function fetch_row($result)
    {
       //Ritiro la riga del risultato
       return mysql_fetch_row($result);
    }

    public function fetch_assoc($result)
    {
       //Il risultato sara' considerato come un array associativo
       return mysql_fetch_assoc($result);
    }

    public function fetch_object($result)
    {
       //Il risultato sara' considerato come un oggetto
       return mysql_fetch_object($result);
    }

    public function num_rows($result)
    {
       //Controllo il numero di righe
       return mysql_num_rows($result);
    }
  
    public function close()
    {
       //Chiudo la connessione al database
       return mysql_close($this->link);
    }
   //Creo il metodo per restituire la variabile privata $link 
   public function getLink()
   {
      return $this->link;
   }
}
?>

Questo e' il listato della classe, mentre quello che segue e' il listato dell'uso della classe

<?php
   include "conf.inc.php";
   function __autoload($class_name)
   {
      require_once($class_name.".class.php");
   }
   
   try
   {
      $db = new MySQL;
      $db->connect($dbHost, $dbUser, $dbPsw, true, 0);
      $db->open($dbName);
      echo $db->getLink;
      echo "Eppure sopra di me dovrebbe apparire il link...";   
   }
   catch (Exception $e)
   {
      echo "Eccezione: ".$e->getMessage();
   }
?>

Sono nuovo del mondo della programmazione, ma vorrei capire fin da subito come sia possibile scrivere buone applicazioni, come potete vedere sto anche imparando ad usare le eccezioni, anche se non ho ancora capito a fondo la loro utilita' sono convinto che il loro uso intensivo me le fara' scoprire!!

risposto 9 anni fa
Pr0v4
X 0 X

Non stavo parlando di API che come dice Gianni sono un'altra cosa e fanno il miele :P

Il fatto che in API la I stia per Interface non vuole dire che ogni volta che si parli di interfaccia si stia parlando di API.

Le interfacce alle classi comeha pure ribadito Gianni, sono appunto le interfacce utente per le classi, le API fanno parte di una classificazione più ampia che nulla ha a che fare con il mio discorso.

risposto 9 anni fa
Marco Grazia
X 0 X

ehehe lo so, non mi sono espresso proprio nel migliore dei modi :P

ho comunque approfondito quello che già sapevo e rimpiazzato quello che era sbagliato :D

:bye:

risposto 9 anni fa
Andrea Turso
Andrea Turso
86
X 0 X
Effettua l'accesso o registrati per rispondere a questa domanda