L’implementazione del pattern MVC (Model-View-Controller) di Zend Framework, in accordo con le regole di naming implementate dal framework, richiedono uno schema di questo tipo:

==> richiesta al controller (www.dominio.com/news/list)

==> attivazione della action corrispondente (chiamata al metodo listAction() del controller “news”)

==> gestione dei dati nel model (vengono recuperati dal databse i dati richiesti e passati al controller)

==> ritorno del responso al controller (il controller recupera i dati restituiti dal model e li assegna alla vista)

==> visualizzazione dei dati nella vista corrispondente (la vista visualizza i dati risultati dalla richiesta ricevuta al primo passaggio )

Per quanto riguarda il naming, invece, il framework richiede che ci sia una corrispondenza tra la richiesta (URL) e gli elementi MVC :

- URL = www.dominio.com/news/list

- nome del controller (NewsController)

- nome della action (listAction)

- file della vista che contiene il codice HTML per la visualizzazione del responso (list.phtml)

I colori ci aiutano a chiarire le corrispondente. Ci sono dei casi però in cui tutto il meccanismo che implementa l’MVC non è necessario. In alcuni casi, infatti, il file della vista (nel nostro caso list.phtml) non è necessario.

Pensiamo ad esempio all’azione di caricamento (upload) di un file: in questo caso ci interessa richiedere al controller che si occupa della gestione dei file di attivare la action adibita alla gestione del caricamento, ma senza richiamare un file di visualizzazione, restituendo invece un semplice messaggio per fornire il feedback sul successo o meno dell’operazione.

Per ottenere la disabilitazione del layout e il richiamo automatico della vista possiamo servici dell’helper messo a disposizione da Zend Framework stesso:

$this->_helper->layout->disableLayout();
$this->_helper->viewRenderer->setNoRender(true);

Inserendo queste righe di codice all’interno della action del controller comunichiamo al framework di disabilitare il layout e dunque la visualizzazione del risultato nel corrispondente file .phtml . In questo modo Zend Framework non andrà a cercare il file della vista, e noi siamo liberi di utilizzare il risultato della richiesta nel modo più adeguato alle necessità del nostro applicativo.

L’argomento che trattiamo in questo articolo è la gestione delle transazioni con Zend Framework. Una transazione è una sequenza di operazioni che deve rispettare le proprietà ACID ( Atomicity, Consistency, Isolation, e Durability – Atomicità, Coerenza, Isolamento e Durabilità). Una transazione può terminare con successo o con un insuccesso: nel primo caso il risultato sarà permamente, mentre nel caso di insuccesso di deve tornare alla situazione precedente l’inizio della transazione, come se nulla fosse successo.

Una transazione inizia con l’istruzione che dichiara appunto l’ “inizio della transazione” ( il punto (1) nel codice). Le operazioni che intendiamo eseguire tutte insieme sul database vanno inseriti dopo questa istruzione (1), all’interno di un blocco “try{} catch {}” che permette di verificare che tutto abbia funzionanto e pertanto che non siano state lanciate eccezioni.

Nel nostro esempio vogliamo eseguire due operazioni di inserimento sul database (2), utilizzando i modelli “$model” e “$model2″ (Zend Framework si basa su una implementazione del pattern MVC, Model-View-Controller). Vorremmo che queste operazioni di inserimento avvennissero una dopo l’altra, e che vengano annullate nel caso in cui una delle due “INSERT” non andasse a buon fine. I dati che vogliamo inserire li organizziamo in una struttura dati simile a quella nel punto (3) del codice (in sostanza un array associativo).

Nei punti (4) e (5) dell’esempio effettuiamo gli inserimenti veri e propri. Se tutto funziona senza problemi, effettuiamo l’operazione di COMMIT (6) per confermare la correttezza della transazione e dunque la conseguente chiusura della stessa.

Nel caso in cui invece  si siano verificati problemi, verrà lanciata una eccezione che sarà catturata dal blocco “catch”, nel quale, prima di riportare il messaggio dell’errore e lanciarlo alla classe padre (8), eseguiamo l’azione di ROLLBACK (7). Questa è l’istruzione che comunica alla transazione che ci sono stati problemi e che dunque deve essere annullata, senza apportare modifiche permanenti alla base di dati.

(1) $this->getAdapter()->beginTransaction();
try {

  // TODO ho aggiunto io l’autoincrement nelle tabelle articoli
  (2) $model   = new My_Model();
  $model2 = new My_Model2();
  (3) $data   = array("nome"=>"Marco", "cognome"=>"Lecce");
  $data2 = array("tipo"=>"Utente", "ruolo"=>"Editore");
  (4) $id = $model->insert($data);
  (5) $id2 = $model2->insert($data2);

  (6) $this->getAdapter()->commit();

} catch ( Zend_Exception $e ) {

  (7) $this->getAdapter()->rollBack();
  (8) throw new Exception( $e->getMessage() );

}

Come abbiamo visto sono sufficienti queste poche righe di codice per gestire un importante concetto come quello delle transazioni. Il codice rimane dunque pulito e molto leggibile: per ora è tutto, ci vediamo al prossimo articolo con Zend Framework!

Il “Code Assistant” di Eclipse è uno strumento molto potente, che non solo suggerisce le librerie di default del linguaggio di programmazione con il quale stiamo lavorando (Java, PHP, ecc.) ma permette anche di personalizzare le librerie a disposizione, aggiungendone ad esempio di terze parti.

Questo non solo velocizza la scrittura del codice, ma permette anche di imparare molto più rapidamente il linguaggio o i framework che stiamo utilizzando nel nostro applicativo. Quando però lavoriamo in team su un progetto, è molto probabile che si utilizzino i plugin come quello di subversion per gestire il lavoro. Il problema è che quando lavoriamo in questo ambiente, di default, il progetto perde l’indicazione sulla sua stessa natura….in pratica Eclipse non sa più se stiamo lavorando in PHP o Java, sa solo che stiamo lavorando con subversion, perdendo in questo modo il prezioso aiuto che ci fornisce il Code Assistant. Ma per risolvere questo problema ci vogliono davvero 5 minuti…

Dobbiamo concentrare la nostra attenzione sui file “.buildpath” e “. project” del nostro progetto Eclipse: se li editiamo noteremo che non vi sono indicazioni circa la natura del progetto (cioè se siamo in ambiente Java, PHP o Javascript). Tutto ciò che dobbiamo fare è inserire nei rispettivi file le seguenti direttive in neretto:

.PROJECT

<?xml version=”1.0″ encoding=”UTF-8″?>
<projectDescription>
<name>prova</name>
<comment></comment>
<projects>
</projects>
<buildSpec>
<buildCommand>
<name>org.eclipse.wst.validation.validationbuilder</name>
<arguments>
</arguments>
</buildCommand>
<buildCommand>
<name>org.eclipse.dltk.core.scriptbuilder</name>
<arguments>
</arguments>
</buildCommand>
</buildSpec>
<natures>
<nature>org.eclipse.php.core.PHPNature</nature>
</natures>
</projectDescription>

.BUILDPATH

<?xml version=”1.0″ encoding=”UTF-8″?>
<buildpath>
<buildpathentry kind=”con” path=”org.eclipse.php.core.LANGUAGE”/>
<buildpathentry external=”true” kind=”lib” path=”/myLibrary”/>
<buildpathentry kind=”src” path=”"/>
</buildpath>

A questo punto, una volta riavviata l’IDE, il nostro progetto sarà etichettato in base alla sua natura, e dunque si riattiveranno tutte le funzionalità e tutti gli strumenti a disposizione per lo sviluppo con l’ambiente che abbiamo impostato (e il Code Assistant non fa eccezione! )

ExtJs è un framework javascript che è riuscito ad ottenere forti consensi nell’ambito dello sviluppo di interfacce web: questo grazie soprattutto alla potenza del prodotto e alla comunità decisamente attiva che fornisce un importante supporto agli sviluppatori.

Il meccanismo implementato da questo  framework per eseguire chiamate Ajax è estremamente semplice ed intuitivo, meccanismo che tra le altre cose ricorda molto da vicino quello adottato da altri framework javascript come JQuery. Vediamone un esempio:

Ext.Ajax.request({
[…]
url: ‘pagina.php’,
params: {id: ‘3’},
success: function(resp) {
[…]
} ,
failure: function(a, b) {
[…]
}
});

Con queste poche righe di codice, ExtJs ci permette di eseguire una chiamata Ajax verso l’indirizzo specificato nel parametro di configurazione “url” (pagina.php) e di gestire sia il caso di risposta positiva sia il caso di insuccesso.
“params” invece permette di specificare i parametri che verranno inviati al file “pagina.php” durante la chiamata Ajax: nel nostro esempio inviamo un parametro con identificativo “id” che contiene il valore 3.

E se volessimo inviare un array? Nessun problema, ci viene in aiuto JSON.

ExtJs è chiaramente progettato per fornire pieno supporto a JSON, dunque possiamo sfruttare questo protocollo. Codifichiamo quindi il nostro array utilizzando le funzioni che ExtJs ci mette a disposizione, come ad esempio la seguente:

Ext.encode(array)

Supponendo quindi di voler inviare un array di valori con una chiamata Ajax il nostro codice potrebbe diventare:
Ext.Ajax.request({
[…]
url: ‘pagina.php’,
params: {data: Ext.encode(arrayData)},
success: function(resp) {
[…]
} ,
failure: function(a, b) {
[…]
}
});

Lato server, sarà sufficiente eseguire il decoding del parametro “data”, che giunge al server sottoforma di stringa JSON:

$myArray = json_decode($_POST[‘data’]);

Vi sono varie versione pre-configurate di Eclipse, in base alle esigenze dello sviluppatore: c’è la versione per gli sviluppatori J2EE, per applicazioni Java Mobile, per sviluppatori PHP, ecc.

Ma è anche possibile scaricarsi la versione base e scegliere “a mano” la configurazione che si preferisce, installando i plugin che necessitano allo sviluppatore.

Anche se Eclipse nasce principalmente per gli sviluppatori Java, negli ultimi anni sono state perfezionate versioni per i principali linguaggi web-side, come ad esempio PHP e Ruby. In questo articolo andremo a vedere come integrare il manuale PHP all’interno dell’IDE, in modo da avere a portata di click le principali librererie che questo linguaggio di programmazione mette a disposizione.

Di default, il PDT (PHP Development Tools ) di Eclipse segue il manuale online del famoso sito www.php.net: ovviamente questa è la scelta più comoda, visto che è sicuramente la documentazione più aggiornata di questo linguaggio. Il problema è che questa soluzione vale per un pc sempre connesso a Internet. Se abbiamo la necessità di lavorare sempre con la documentazione, anche quando non siamo connessi (e sarebbe un bene che tutti gli sviluppatori lo facessero), allora dobbiamo seguire questi semplici passi:

1) dal sito di riferimento www.php.net scarichiamo la versione html del manuale, situata al seguente indirizzo www.php.net/download-docs.php (nel caso il download sia congestionato, si può scaricare la documentazione anche dal mirror italiano, al seguente indirizzo)

2) Una volta scaricato e unzippato l’archivio, apriamo Eclipse (con il PDT già installato), andiamo su:

Window –> Preferences –> PHP —> PHP Manual

e creiamo un nuovo elemento cliccando sul tasto “New” e selezionando l’inserimento da cartella.

3) Ad inserimento effettuato, clicchiamo sul nuovo elemento e poi sul tasto “Default” se vogliamo che questa sia la versione di default del nostro manuale

A questo punto abbiamo finito: avremo a disposizione per il nostro sviluppo PHP il manuale e la documentazione vitale per ogni sviluppatore, sia che siamo connessi a Internet sia nel caso in cui ci troviamo a lavorare in assenza di connessione.

Ecco perchè diventa molto importante saper gestire questo tipo di dato. Vi sono molti modi differenti di manipolare le date, ma quello che vogliamo presentare oggi è una soluzione che riguarda il salvataggio di date in una base di dati e il conseguente recupero.

Molti programmatori utilizzano le funzioni di manipolazione delle stringhe per formattare le date, ignorando che tale soluzione è poco performante ed ancora meno efficiente. Quando si lavora ad un progetto con un database alle spalle, bisogna sempre tenere presente che far eseguire alcuni tipi di operazioni al DBMS piuttosto che all’interpreste del linguaggio di programmazione (nel caso del PHP, ad esempio) è sicuramente molto più performante oltre che leggibile.

Bisogna a questo scopo conoscere alcune funzionalità che i database, o meglio, i DBMS, mettono a disposizione. Una di queste è proprio DATE_format , che appunto durante una interrogazione permette di inserire nel result set le date già formattate e pronte per l’utilizzo.

Vediamo un esempio:

SELECT title, created DATE_format(created, ‘ %e/%m/%Y, %l:%i%p’) as created
FROM table
WHERE category=1
ORDER BY created DESC

Supponiamo di avere una tabella per le notizie, da cui vogliamo recuperare il titolo e appunto la data di crezione di ogni item.

Attraverso l’utilizzo della funzione DATE_format messa a disposizione dal motore di MySQL, riceviamo una data già formatta è pronta per l’uso, senza dover richiamare ulteriori funzioni di formattazione o di manipolazione di stringhe, con un conseguente aumento delle prestazioni (seppure di pochi microsecondi nella maggior parte dei casi) e della leggibilità del codice.

DATE_format accetta due parametri: il primo è la data da formattare, il secondo è una stringa di formattazione, che segue delle regole simili a quelle utilizzate per questo tipo di stringhe dalla maggior parte dei linguaggi di programmazione, e che trovate qui.

A questo punto, quando si utilizzerà il relativo result set, si potranno usare direttamente sia il campo title che il campo created senza ulteriosi interventi da parte del programmatore.

In questo ambito può essere davvero utile conoscere il meccanismo di funzionamento delle sessioni in Joomla. A differenza di quanto si crede, Joomla può essere considerato un vero e proprio framework, con le sue API e tutto ciò che serve per sviluppare componenti realmente e completamente integrati con il sistema.

Uno di questi oggetti, sicuramente tra i principali, è il JFactory: mediante questo oggetto infatti è possibile tra le altre cose gestire ad esempio le connessioni con il database, e, per l’appunto, le sessioni. Vediamo il procedimento esatto.

Il primo passo è recuperare la sessione e salvarla in una variabile che ne permetta l’utilizzo:

$session =&JFactory::getSession();

Notiamo che utilizziamo l’oggetto JFactory per salvare all’interno della variabile $session un riferimento alla sessione, che possiamo utilizzare per settare un valore:

$my_value = “variabile di sessione”;

$session->set(‘my_value’, $my_value);

In questo modo utilizziamo l’istanza della sessione precedentemente recuperata per memorizzare la variabile $my_value all’interno della sessione stessa. Il nome del parametro ‘my_value’ non deve ovviamente essere per forza uguale a quello della variabile ($my_value), anche se è buona norma utilizzare lo stesso nome per il parametro e per la variabile, in modo da facilitare la programmazione.

Il valore precedente salvato in sessione è facilmente recuperabile attraverso il seguente comando:

$my_value = $session->get('my_value');

Come possiamo vedere, quindi, il framework Joomla mette a disposizione tutta una serie di strumenti che facilitano il compito dello sviluppatore: è importante conoscere tali strumenti, perchè sono stati concepiti proprio per facilitare l’integrazione del nostro codice con quello del CMS, integrazioni da implementare nel modo corretto, se vogliamo che il nostro sistema rimanga stabile e sicuro.

Il lavoro di squadra richiede da parte delle figure coinvolte pazienza e dedizione, e la strada da scegliere deve essere quelle del dialogo costruttivo e del rispetto delle idee di ognuno dei partecipanti.

Vi sono strumenti che è molto importante conoscere, perchè permettono di sincronizzare il lavoro del team e di gestire in modo professionale e ordinato progetti di dimensioni importanti. In questo articolo vedremo come configurare un ambiente di sviluppo professionale per il team development, ma non bisogna mai dimenticare un elemento importante: gli strumenti che vedremo sono molto potenti ed utili, ma non sono adatti a tutte le situazioni e a tutte le tipologie di progetto.

Uno strumento potente, ma inadatto alle caratteristiche dei progetti o dei movimenti produttivi interni dell’azienda, può provocare danni non indifferenti.

L’ambiente che andremo a configurare ha i seguenti requisiti:

1. un server linux (fedora 10)
2. Apache, PHP, MySql installati nel server e nella propria macchina
3. IDE Zend Studio for Eclipse (o anche solo Eclipse) installato nella propria macchina

Il sistema che andremo a configurare  è dunque composto da un server Linux su cui installaremo l’svn (subversion), e da una o più workstation su cui sarà configurato un ambiente di sviluppo in locale e l’IDE che ci permette di gestire i collegamenti con subversion e dunque di lavorare in team con i nostri colleghi.

Configurazione del SERVER

Avendo scelto come sistema operativo Fedora 10, possiamo utilizzare il tool yum per installare subversion su linux:

yum install subversion

Per renderlo avviabile in Apache, installiamo il modulo mod_dav_svn:

yum install mod_dav_svn

Nella directory root del server, creiamo le seguenti cartelle per il repository svn:

mkdir /svn/repos
svnadmin create /svn/repos/projects

Per questioni di permessi, è necessario cambiare il proprietario della cartella in “apache” :

chown -R apache.apache /svn

A questo punto, dobbiamo creare il file in cui verranno scritte le policy di sicurezza che controllano la metodologia di accesso ai progetti. Creiamo il file svnauth nella directory /svn/repos/projects/svnauth e inseriamo le utenze come da esempio seguente:

[/]
user1 = rw
user2 = r

user1 in questo caso avrà accesso in lettura-scrittura, mentre user2 avrà l’accesso in modalità in sola lettura in tutto il repository.

Il passo successivo è creare il file (/svn/repos/projects/svnpass) che conterrà le password degli utenti di cui sopra:

htpasswd -bcm /svn/repos/projects/svnpass user1 passwordUser1
htpasswd -bm /svn/repos/projects/svnpass user2 passwordUser2

Lanciando i comandi precedenti, creiamo un’associazione tra utente e password, e tale associazione verrà appunto scritta nel file svnpass. Importante: notate che i parametri del primo comando (-bcm) sono diversi dal secondo (-bm); questo perchè nel secondo caso andiamo solo ad aggiungere una riga al file svnpass, mentre nel primo caso è impostata anche la creazione opzionale del file nel caso in cui questo non esistesse. I parametri associati al comando htpassw hanno il seguento significato:

-c    creazione nuovo file

-m   forzare la crittografia MD5 della password

-b    usare la password inserita da linea di comando

Per ulteriori chiarimenti sul comando htpasswd consigliamo di leggerne la documentazione, anche perchè ci sono alcune differenza in base al sistema operativo in uso.

Ora è arrivato il momendo di configura Apache; aggiungiamo allora le seguenti righe al file di configurazione del server web:

<Location /svn/sandbox>
DAV svn
SVNPath /svn/repos/sandbox
AuthType Basic
AuthName "Subversion Repository"
AuthUserFile /svn/repos/sandbox/svnpass
Require valid-user
AuthzSVNAccessFile /svn/repos/sandbox/svnauth
</Location>

Riavviamo Apache, e l'ambiente server è pronto per essere utilizzato. Se tutto funziona regolarmente, il repository dovrà essere accessibile da browser al seguente indirizzo http://www.yourserver.com/svn/projects.

Sarà richiesta una login e una password, che ovviamente dovranno corrispondere a quelle che abbiamo procedentemente inserito.

Ora manca il passo finale, quello della configurazione del nostro IDE. Consideriamo a questo punto che su ogni macchina prediposta per il team development vi siamo già configurato un ambiente di sviluppo classico per lo sviluppo locale in PHP (Apache-PHP-MySql).

In questa sede sarebbe troppo dispersivo e lungo descrivere il procedimento passo per passo: vi sono diversi pacchetti com xxamp o wamp che si possono usare per configurare in pochi minuti un ambiente di sviluppo in PHP perfettamente funzionante in ambiente Windows (nelle release Linux più diffuse, è già tutto prediposto per una installazione di tale ambiente), anche se il nostro consiglio è di procedere con installazioni manuali di cui si ha il completo controllo. L’unico appunto è di far puntare la directory root di apache nel workspace che abbiamo scelto durante la configurazione della IDE: in questo modo rendiamo visibili i nostri progetti ZEND o ECLIPSE nel nostro localhost.

La configurazione che vedremo è esattamente la stessa sia che si utilizzi Zend Studio for Eclipse che Eclispe con il plugin Php. Quest’ultima, come la maggior parte degli utenti sapranno, è completamente gratuita, e fornisce gli stessi strumenti di Zend Studio per quando riguarda il team development. Chiaramente Zend Studio è la piattaforma specifica per lo sviluppo in PHP, e sicuramente per un web developper professionista è il top in quanto a strumenti forniti e comodità di sviluppo. Tuttavia, per chi sviluppa in più di un linguaggio di programmazione a livelli professionali, Eclipse, a nostro avviso, risulta essere la scelta più versatile e comoda.

Procediamo alla configurazione della nostra IDE:

1) Apriamo la prospettiva SVN Repositories

2) Nella colonna di destra, andiamo ad aggiungere il nostro repository (tasto destro + new)

2.1) Inserire l’URL  del repository http://www.tuoserver.com/svn/projects.

2.2) Inserire l’user e la pass dell’utente che utilizzerà tale ambiente e che rientrano in quelle precedentemente configurate

2.3) Clicchiamo su “Finish”

A questo punto il repository verrà importato nel nostro ambiente: concluso tale processo, apriamo la prospettiva “PHP Explorer” (o Resource), che sarà la prospettiva vera e propria che useremo per lo sviluppo. Creiamo un nuovo progetto:

1) New Project

2) Svn –> Project from SVN

3) Selezionare l’uso di un repository esistente

4) Scegliere il/i progetto/i, la data attuale e procedere cliccando su “Finish”

A questo punto verrà eseguito il checkout del progetto: questo procedimento impiegherà qualche minuti prima di concludere.

Siamo pronti per testare il meccanismo, tornando ad analizzare la sezione “PHP Explorer” della nostra IDE.

La prima cosa che notiamo sono dei “numeri” presenti su ogni risorsa all’interno del progetto: questo “numero” identifica la versione della risorsa: subversion, infatti, gestisce un potente e importante strumento di versioning, che facilita nelle operazioni di update o di recupero.

Cliccando con il tasto destro del mouse sul nome del progetto, e scegliendo “Team”, si apre un menu contestuale che ci mette a disposizione tutti gli strumenti potenti di gestione del team development e di subversion.

La operazioni principali sono UPDATE e COMMIT : la prima permette di ricevere le modifiche che gli altri membri del team hanno portato al progetto eseguendo un commit. Il COMMIT, appunto, è l’operazione più importante, perchè permette di scrivere sul progetto finale, direttamente sull’snv: bisogna per questo fare molto attenzione durante questa operazione, essere sicuri che ciò che si sta “commitando” sia perfettamente funzionante e ricordarsi sempre di commentare il proprio COMMIT per permettere una facile gestione del versioning.

Vi sono tantissime altre funzionalità molto importanti e potenti che possiamo sfruttatare per lavorare al meglio con questi strumenti, ma per ora riteniamo siamo meglio fermarci qui….abbiamo già abbastanza elementi da testare! Chiaramente, nel caso ci fossero domande o questione di qualsiasi tipo, siamo a  vostra disposizione!!

Ad esempio, potremmo avere la necessità di inserire nelle nostre pagine una mappa di google che, a
seconda dell’indirizzo passato (e quindi dinamicamente), visualizzi la posizione desiderata con un “marker” e le informazioni relative.
Lo script per implementare tale meccanismo è il seguente:

<script type=“text/javascript”>
var map = null;
var geocoder = null;

<div id=“nomap” style=“color: red;”></div>
<div id=“map” style=“width: 300px; height: 200px;”></div>

Il codice HTML delle ultime due righe crea due div: il primo serve per visualizzare un messaggio di
warining nel caso in cui l’indirizzo passato non sia stato trovato dal motore di ricerca, il secondo serve per la visualizzazione della mappa.

Lo script è composto da due funzioni: load() e showAddress(address). La funzione load viene richiamata al caricamento della pagina, ed è ovviamente il cuore di questo script: si occupa di settare tutti i paramentri necessari, tra cui il settaggio dell’id del div che conterrà la mappa (map).
Eseguite tutte le assegnazioni del caso, viene infine richiamata la seconda funzione importante,
showAddress(address).
Questa ha un parametro, address, che potremmo ad esempio generare e passare con computazioni proveniente da pagine php, che è proprio l’indirizzo che verrà visualizzato sulla mappa attraverso l’uso dei marker settati nella prima funzione.
L’indirizzo è un parametro, ed è quindi dinamico: ogni qualvolta la pagina verrà ricaricata, leggerà l’indirizzo attualmente impostato e lo passerà allo script, che si occuperà di visualizzarlo sulla mappa.

In realtà siamo stati un pò troppo precipitosi : c’è un’altra soluzione, ed ha fornirla è chiaramente la IDE professionale e meravigliosa per lo sviluppo PHP, ovvero Zend Studio for Eclipse.

Questo ambiente di sviluppo, oltre a fornire infinite utilissime ed efficentissime funzionalità per il professionista, permette la personalizzazione e la gestione dell’editor: lo sviluppatore può quindi decidere come visualizzare alcuni tipi di file, permettendogli di lavorare più agevolmente anche nelle situazioni più critiche.

Se vogliamo salvare la nostra testolina, ma soprattutto la colonna portante del nostro ufficio, tutto ciò che dobbiamo fare per lavorare tranquillamente con file aventi estensione .tpl è seguire questi semplici e veloci passi:

1) nel menu, andare in Window->Preferences

2) nell Preferences, andare in General->Content Types

3) nella sezione Content Types, scegliere Text->PHP

4) Cliccare sul pulsante “Add”, ed inserire la stringa *.tpl

5) Cliccare sul pulsante “OK”

A questo punto, una volta riavviato il nostro ambiente di sviluppo, i file con estensione .tpl verranno visualizzati come normali file PHP: in questo modo sarà più semplice riconoscere i tag HTML dal codice PHP, rendendo il nostro lavoro più efficiente e comodo. Ovviamente non è obbligatorio scegliere la visualizzazione in PHP al passo 3) : ad esempio, chi preferisce, può associare i file .tpl alla visualizzazione HTML, a seconda delle proprie necessità.