Il redirect permette di reindirizzare la pagine verso un’altra, senza interazione da parte dell’utente e inoltrando perciò le visite verso la nuova destinazione. Vi sono molti modi diversi di fare un redirect, noi vedremo i metodi per i principali linguaggi Web.
Metodo HTML
E’ sufficiente creare una pagina con il seguente codice:
con la quale sostanzialmente indichiamo che la pagina è appunto un redirect, che il redirect verrà effettuando entro 4 secondi e che la destinazione del redirect è la pagina http://www.google.it . Ovviamente se vogliamo che il redirect sia immediato è sufficiente inserire il valore 0 al posto del 4 . Fate attenzione a questo punto: i valori dallo 0 all’1 sono considerati dalla maggior parte dei motori di ricerca come permanent redirect ( codice html 301 ), mentre i valori maggiori di 2 sono considerati temporary redirect.
Metodo Javascript
Creiamo una pagina .html nella quale inseriamo il seguente codice:
In questo caso c’è poco da aggiungere: si crea un piccoloscript javascript nel quale appunto utilizziamo la direttiva location.replace per indicare la presenza di un redirect e dunque la nuova destinazione.
Metodo Php
Nella pagina php in cui vogliamo fare il redirect inseriamo il seguente codice:
In asp sostanzialmente il procedimento è molto simile al metodo php; ecco il codice da inserire nel nostro file asp su cui vogliamo effettuare il redirect:
In Coldfusion è sufficiente utilizzare la seguente riga:
<cflocation url=”http://www.google.it”>
Anche se non è fondamentale, è comunque molto importante conoscere i principali codici di stato HTML : bisogna fare molta attenzione se non si vuole perdere traffico o posizioni sui motori di ricerca. Ecco i principali:
300 Multiple Choices 301 Moved Permanently 302 Found 303 See Other 304 Not Modified 305 Use Proxy 306 (Unused) 307 Temporary Redirect
Una spiegazione più approfondita su tali codici è possibile trovarla in questa pagina , ovvero nelle pagine del World Wide web Consortium.
Di default, la configurazione del motore PHP permette di uplodare file di dimensioni non superiori ai 2 MB. Nel file di configurazione php.ini , infatti, si trova la seguente direttiva:
upload_max_filesize = 2M
che non fa altro che fissare la dimensione massima per i file in upload a 2 MB, appunto. Molto spesso però tale limite rappresenta un problema, soprattutto quando dobbiamo gestire piccoli file audio e video. Ovviamente nel caso in cui dovessimo implementare applicativi che lavorano con upload di file di grandi dimensione, 100 MB ad esempio, la strada di utilizzare tale direttiva non è certo quella consigliata (il motore PHP e il server web Apache non sono stati concepiti per gestire una tale dimensione di file in upload).
Quindi, quando dobbiamo gestire file di dimensioni superiori hai 2 MB, dicevamo, il limite imposto rimane un problema. Come risolvere dunque la situazione?
Sicuramente l’idea di modificare il valore nella direttiva upload_max_filesize non è la miglior cosa da fare: è bene ridurre al minimo le modifiche al file php.ini , visto che tale file configurare tutto il motore PHP. Aumentare la dimensione dei file nel php.ini l’aumenterà in tutti i progetti implementati in tale linguaggio.
La soluzione migliore è modificare tale impostazione solamente nel dominio o nel progetto interessato: ovviamente tutto dipende dalla configurazione del sistema in cui l’applicativo “gira”.
Se abbiamo la possibilità di accedere al file di configurazione del dominio ( normalmente si chiamano http.include, ma dipende dal sistema utilizzato ovviamente ), è sufficiente aggiungere all’interno del VirtualHost di tale file la direttiva:
php_value upload_max_filesize XM
che altro non fa che impostare il limite al valore X solo per il dominio in particolare, lasciando quindi il limite di default per tutto il resto. Nel caso in cui non si potesse accedere al file di configurazione del dominio, si può procedere inserendo tale direttiva in un file .htacces : in questo modo si ottiene lo stesso effetto senza dover modificare il file di configurazione del dominio.
Da questo momento, il limite per i file in upload sarà di X MB, ma solo per il dominio preso in considerazione!
Manipolare le immagini con PHP è davvero divertente: in poche righe di codice si possono creare degli effetti e delle particolarità davvero interessanti. L’esempio che vedremo in questo articolo mostrerà come modificare dinamicamente un’immagine data o passata come parametro: nel dettaglio, andremo a scrivere sull’immagine data una particolare stringa, di cui possiamo modificare colore, posizione, carattere, ecc.
L’esempio di ciò che andremo ad implentare è disposibile a questo indirizzo qui.
Creiamo un file php, figure.php, e analizziamo il codice da inserire.
<?
/*
Innanzittutto comunichiamo a chi utilizzerà questa pagina (ad es. il browser) che il contenuto della stessa deve essere interpretato come un’immagine. In questo modo, se volessimo utilizzare l’immagine creata con questo codice in un tag html <img>, sarà sufficiente scrivere una riga di questo tipo: <img src=”figure.php” />
*/ header(”Content-type: image/jpeg”);
/*
Assegnamo il valore che avrà la prima stringa che scriveremo nell’immagine. Se ad esempio volessimo fare un album di figurine di calcio, che in base alla figura assegna un nome diverso, si potrebbe “giocare” con queste due stringhe per assegnare il nome e il cognome appropriato in base alla figurina che carichiamo o passiamo come parametro.
*/ $string = strtoupper(”FRANCESCO”);
/*
Assegnamo il cognome del giocatore
*/ $string2 = strtoupper(”TOTTI”);
/* imagecreatefromjpeg è una funzione php che permette di creare un’immagine da un file o da un URL. Nel nostro caso creiamo una figurina da un’immagine di partenza, quella passata come parametro. La funzione restituisce un identificativo ($im) che rappresenta l’immagine create dal nostro file di partenza. Attraverso questo identificativo possiamo modificare l’immagine a nostro piacimento.
*/ $im = imagecreatefromjpeg(”http://www.marcolecce.com/blog/Esempi/esempio7/totti.jpg”);
/* imagecolorallocate permette di creare ed allocare un colore ad un’immagine. Anche in questo caso viene restituito un identificativo ($color) che rappresenta il colore secondo i componenti RGB passati come parametri.
*/ $color = imagecolorallocate($im, 255, 255, 255);
/*
Attraverso queste due istruzioni ci calcoliamo la posizione in cui verrano stampate sull’immagine le stringhe che passiamo come parametri. Nel nostro caso stampiano nome e cognome del giocatore nel centro dell’immagine che andremo a creare.
*/ $px = (imagesx($im) - 7.5 * strlen($string)) / 2;
$px2 = (imagesx($im) - 7.5 * strlen($string2)) / 2;
/* imagestring è la funzione che permette di disegnare la stringa sull”immagine: il primo paramettro è l’identificativo dell’immagine, poi c’è le dimensione del carattere, la posizione orizzontale, la posizione verticale, la stringa ed infine il colore.
*/
imagestring($im, 100, $px, 60, $string, $color);
imagestring($im, 100, $px2, 90, $string2, $color);
/*
Infine utilizziamo la funzione imagejpeg che invia in output al browser o ad un file l’immagine che abbiamo creato (nel nostro caso creiamo una jpg, ovviamente vi sono le corrispettive funzioni per gli altri formati come gif, png,ecc; ATTENZIONE: se combiate formato ricordate di far coincidere quest’ultimo con quello dichiarato alla prima di riga di codice, altrimenti non ci sarà corrispondenza e vi saranno problemi di visualizzazione.
)*/
imagejpeg($im);
/*
Una volta visualizzata l’immagine, se non ci serve per altro, possiamo liberare con la funzione imagedestroy() la memoria occupata dall’immagine.
*/
imagedestroy($im);
?>
Ovviamente l’esempio qui presentato è molto semplice, ma il meccanismo di funzionamento rimane pressocchè il medesimo utilizzando le altre funzioni che il PHP mette a disposizione: da questo momento, potete provarle tutte sulla vostra immagine “virtuale”…buon divertimento!
Supponiamo di voler salvare in un array i nomi delle immagini contenute in una determinata directory, in modo da, ad esempio, utilizzarea tale array per la gestione di una gallery.
Vediamo come al solito un esempio pratico commentato per spiegare al meglio tutti i passi necessari:
/*
Creiamo un array $images per contenere i nomi delle immagini che sono salvate nella directory in questione
*/ $images = Array();
/* mydir è il percorso fisico della directory in cui si trovano le immagini
*/ $dir = ‘mydir’;
/* photodir è il percorso virtuale della directory in cui si trovano le immagini
*/ $virtual = “photodir”;
/*
Se la direcotry esiste…
*/ if ( file_exists($dir) ) {
/* readdir restituisce il nomefile del file successivo della directory: in pratica facciamo un ciclo (while) sulla directory finchè ci sono file da leggere, e per ogni iterazione salviamo il nome del file nella variabile $file
*/ while ( false !== ( $file = readdir($handle) ) ) {
/*
Se $dir.$file è un file esistente nel nostro filesystem….
*/ if ( is_file($dir.$file) ) {
/*
..inseriamo il file nell’array images, attraverso il metodo array_push()
*/ array_push($images,$file);
/*
Se la directory è inesistente, stampiamo un avviso come feedback..
*/ } else echo “Directory Inesistente!”;
Attraverso queste semplici linee di codice, alla fine del ciclo avremo disponibili nell’array $images tutti i nomi dei dile contenuti nella directory mydir .
L’ RSS ( Really Simple Syndication ) è diventanto ormai uno dei più popolari formati per lo scambio di contenuti sul Web. E’ basato su XML, da cui non solo ha ereditato la semplicità e la flessibilità, ma anche la possibilità di portersi adattare a qualsiasi piattaforma ( Windows, Linux, ecc. ) .
Per questi motivi sul Web sono molte le guide che spiegano come “scrivere” RSS e mettere a disposizione di tutti i propri contenuti: d’altra parte sono poche quelle che spiegano come utilizzare questi fogli XML per arrichire il contenuto dei propri portali. L’esempio che vedremo spiega come sia possibile, utilizzando il PHP, adattare, leggere e integrare nel proprio sito contenuti distribuiti attraverso questo formato.
Questo articolo non si occupa della generazione di RSS, ma del loro utilizzo, perciò daremo per scontanto l’utilizzo di un codice RSS corretto. Il codice PHP che ci interessa è il seguente:
<table>
<?
/*
Con questa istruzione assegnamo alla variabile $feedUrl il link dell’RSS che per ipotesi supponiamo corretto
*/
$feedUrl = ‘http://dominio.com/link_rss.xml’;
/*
file_get_contents è una funzione php che legge il file all’interno di una stringa, in sostanza “raccoglie” tutto il contenuto del file in una stringa
*/
$rawFeed = file_get_contents($feedUrl);
/*
Questo è il passo principale del nostro frammento di codice: SimpleXmlElement fornisce un metodo semplice e facilmente utilizzabile per convertire un XML in un oggeto che può essere processato con le normali proprietà degli iteratori e degli array.
*/ $xml = new SimpleXmlElement($rawFeed);
/*
Itero sull’oggetto creato: ora posso semplicemente utilizzare i valori di ogni “elemento” di contenuto dell’RSS. Nel nostro esempio supponiamo che l’RSS metta a disposizione l’URL di una immagine, un link, un titolo, una descrizione per ogni riga di contenuto del Feed.
*/
foreach ($xml->channel->item as $item) {
echo “<tr>
<td>
<img src=’”.$item->image.”‘ />
</td>
<td >
<strong><a href=’”.$item->link.”‘>”.htmlspecialchars_decode($item->title).”</a></strong>
<br />”.$item->description.”
</td>
</tr>
<tr><td> </td></tr>
“;
}
?>
</table>
Come è ormai nostra abitudine, abbiamo ampiamente commentato direttamente il codice, in modo da facilitarne l’appredimento. In pochissimi passi, abbiamo recuperato e integrato completamente nel nostro portale contenuto multimediale (testo, immagini, ecc.) provenite da una fonte esterna. Proprio questa è la forza di questa tecnologia: la semplicità e la leggerezza. In pochi passi, abbiamo creato una tabella, in cui ad ogni riga corrisponde un elemento del nostro RSS di esempio.
Per aggiugere l’effetto scorrevole, è sufficiente utilizzare il tag <marquee>, che permette tra le altre cose anche di modificare la velocità di scorrimento. Vediamo un esempio:
Con questa riga di codice creiamo l’effetto a scorrimento: possiamo utilizzare l’attributo “direction” per specificare la direzione, l’attributo “scrollDelay” per specificare la velocità (valori più bassi = velocità maggiore) e gli attributi “onMouseOver” e “onMouseOut” con le realtive funzioni “stop()” e “start()” per far sì che lo scrolling si fermi quando il mouse è sopra l’elemento ma riprenda non appena il mouse esce dall’elenco degli elementi.
Per chi volesse scaricare il codice, può comodamente cliccare qui.
Ajax ( Asynchronous JavaScript and XML ) è una tecnica di sviluppo web che ha lo scopo di proporre interattivà senza tuttavia dover ricaricare la pagina ad ogni interazione con l’utente. In sostanza, Ajax permette attività in backgroud rispetto ad eventi principali: un esempio tipico di utilizzo di questa tecnica è l’aggiornamento dinamico di elenchi, per esempio utilizzato ultimamente nei social networks. Mentre l’utente può scorrere le notizie e qundi interagire con la pagina, l’elenco delle news inserite si autoaggiorna senza tuttavia dover attedere che sia l’utente stesso ad effettuare l’aggiornamento della pagina.
Questa tecnica ha ormai aperto le porte a nuove tipologie di applicazioni, sempre più interattive e sempre più accattivanti. Ma come funziona Ajax? Ecco un esempio passo-passo di utilizzo di queste tecnologie: i commenti si possono leggere direttamente sul codice, in modo da facilitare la comprensione e velocizzare l’apprendimento. Supponiamo che questo codice sia contenuto in un file
“ajax1.js” :
/*
Questa è la funzione principale di creazione: si crea la variabile obj che conterrà il riferimento all’oggetto XMLHttpRequest l’oggetto principale su cui si agisce. Per garantire la compatibilità viene eseguito un controllo sul tipo di browser, visto che a seconda della tipologia l’oggetto obj viene creato in modi diversi. Se il browser è “non - Internet Explorer”, allora si utilizza la funzione XMLHttpRequest altrimenti se il browser è Internet Explorer si utilizza ActiveXObject(”Microsoft.XMLHTTP”). Questa differenza ha una base teorica, che non trattiamo in questa sede, occupandoci qui di “pura pratica”. Se volete approfondimenti scriveteci, e provvederemo ad esaudire le vostre richieste!
*/ function createXHR() {
var obj;
if (window.XMLHttpRequest) { // Non Internet Explorer
obj = new XMLHttpRequest();
} else if (window.ActiveXObject) { // Internet Explorer
obj = new ActiveXObject(”Microsoft.XMLHTTP”);
}
return obj;
}
obj=createXHR();
/*Questa è la funzione che gestisce e analizza lo stato dell’applicazione: si procede innanzittutto con dei controlli, che possiamo fare analizzando lo stato dell’oggetto obj precedentemente istanziato. Se durante il cambiamento si stato dell’oggetto obj non si sono verificati errori, allora le funzioni readyState e status ritorneranno rispettivamente i valori 4 e 200, valori che indicano appunto l’avvenuto caricamento con successo. A questo punto possiamo scrivere il codice che deve eseguire l’appilcazione per raggiungere il suo obiettivo. Nel nostro caso, una volta ricevuta la richiesta, la nostra piccola applicazione Ajax provvedrà a creare una select caricando il contenuto dinamicamente, cioè una select che cambia le opzioni in base ad una scelta fatta dall’utente ma senza il bisogno di ricaricare l’intera pagina.
*/
function onStateChange() { // Cambiamento Stato
if (obj.readyState == 4) { // Caricamento Avvenuto
if (obj.status == 200) { // con successo
var div = document.getElementById(’risultato’);
if ( document.uniqueID ) {
var select = document.createElement(”<select id=’district’ name=’district’ ></select>”);
} else {
var select = document.createElement(”select”);
}
select.setAttribute(”name”,”district”);
select.setAttribute(”id”,”district”);
select.setAttribute(”onchange”,”invia2();”);
list = new Array();
list1 = new Array();
list2 = new Array();
/*IMPORTANTE: tramite la proprietà responseText dell’oggetto obj è possibile recuperare valori prodotti dal file che si occupa di gestire la richiesta al server, per esempio il file che effettua una query e che nel nostro caso è xmlHttpRequest.php*/
string = obj.responseText;
list = string.split(”;”);
list1 = list[0].split(”\n”);
list2 = list[1].split(”\n”);
for ( i=0; i < list1.length; i++ ) {
op = new Option(list2[i], list1[i]);
select.options[i] = op;
}
document.getElementById(”risultato”).innerHTML=”";
div.appendChild(select);
/*La funzione invia() è quella da cui inizia l’attività: infatti questa funzione non fa altro che inviare alla funzione inviaXHR() il riferimento all’oggetto obj e il link del file di gestione
*/
function invia() {
/*Questo è il cuore dell’applicazione: attraverso una richiesta POST, inviamo con la funzione send() i dati al file xmlHttpRequest.php, chepotrà svolgere il suo compito indipendentemente dalle altre interazioni che l’utente potrà avere con la pagina. Nel nostro caso, supponiamo che in questo file ci sia il codice per effettuare una query al database, e che con i risultati ottenuti si crei l’insieme delle opzioni che andranno a “riempire” la select di cui sopra. Supponiamo di aver creato una stringa in cui ogni attributo value dell’opzione è separato dal valore visibile dal carattere “|”, cioè:
// caricamento in corso…fornisce il feedback all’utente document.getElementById(”risultato”).innerHTML=”caricamento in corso…”;
obj.setRequestHeader(’Content-Type’, ‘application/x-www-form-urlencoded’);
//richiamiamo la funzione onStateChange analizzata precedentemente obj.onreadystatechange = onStateChange;
/*IMPORTANTE: a seconda del valore country possiamo gestire la select
che vogliamo creare, e quindi possiamo aggiornarla in base a determinati valori che vengono assegnati a country
*/
country=escape(document.myform.country.value);
//Inviamo al file di gestione .php alcuni parametri, attraverso il metodo POST
obj.send(”country=”+country); // Trasferimento
} catch (e) {
/* Se si verificano problemi, l’elemento HTML che doveva diventare una select verrà sostituiro con un ?, che indica appunto il verificarsi di errori o problemi
*/
document.getElementById(”risultato”).innerHTML=”?”;
alert(”Errore: “+e);
}
}
Per chi avesse le idee ancora confuse, riassumiamo brevemente ciò che succede.
Creaimo l’oggetto obj.
Supponiamo di cliccare su un pulsante che richiama la funzione javascript “invia()”; attiviamo così una richiesta al server.
Tramite la funzione inviaXHR gestiamo effettivamente la richiesta: il metodo utiliaazto è il POST (con cui possiamo inviare dati al file di gestione) e il file di gestione è xmlHttpRequest.php, che nel nostro caso è scritto in PHP ma che potrebbe essere scritto in un qualsiasi linguaggio di programmazione. La funzione send() ci permette di inviare parametri al file di gestione, parametri che vengono inviati attraverso il metodo POST, appunto.
Il file di gestione può fare qualsiasi cosa per svolgere il suo compito: supponiamo nel nostro caso che il file effettui una query al database e restituisca una stringa.
Viene richiamata la gestione di stato dell’oggetto, onStateChange, che analizza l’andamento della richiesta che abbiamo effettuato. Se tutto è andato bene, recuperiamo attraverso la proprietà responseText dell’oggetto obj la stringa prodotta dal file di gestione. Possiamo lavorare sulla stringa restituita, creando ad esempio una select con delle option che dipendono dal valore di un parametro scelto dall’utente, nel nostro caso country.
Tutto questo lavoro viene svolto in background, senza che l’utente di accorga di nulla, ma soprattutto permettendo all’utente di continuare ad interagire con la pagina liberamente e come se nulla stia accadendo.
Per gli sviluppatori è di vitale importanza conoscere gli eventuali problemi o errori che precludono il corretto funzionamento di ciò che stanno implementando: vi sono diversi sistemi per conoscere tali informazioni, ma più il sistema adottato è veloce, più il programmatore lavora rapidamente e bene.
Questo vale ancora di più per coloro che si trovano a sviluppare con linguaggi lato server come PHP: infatti vi sono alcuni tipi di errori che con queste tecnologie non sono facili da individuare senza un aiuto preciso e puntuale, e il più delle volte si perde tantissimo tempo alla ricerca del problema, con il conseguente ritardo nel lavoro. Ovviamente vi sono i log a disposizione, ma bisogna avere un accesso completo ( o quasi ) al server per visionarli, e non tutti i programmatori chiaramente hanno questa possibilità.
Dunque, come possiamo semplificarci l’individuazione dei problemi quando stiamo implementando una pagina .php? In realtà la risposta è molto semplice; è sufficiente scrivere in cima alla nostra pagina le due seguenti righe di codice:
Queste righe di codice permettono di visualizzare a video i problemi o gli errori presenti nella pagina e che vengono scritti nel file di log degli errori del server su cui risiede il dominio.
La funzione “ini_set” non fa altro che impostare il valore di una data opzione di configurazione: in questo caso, il parametro error_reporting() imposta la direttiva error_reporting a runtime. PHP ha diversi livelli d’errore, ed utilizzando questa funzione si imposta il livello per la durata (runtime) dello script.
Il parametro display_errors, invece, determina se gli errori devono essere visualizzati sullo schermo come parte dell’output o se devono essere nascosti all’utente.
Ovviamente queste impostazioni deve essere utilizzata solamente come supporto allo sviluppo, e mai nel sistema di produzione: in caso contrario si rischierebbe di fornire informazioni preziose per chi intende provocare un danno al vostro lavoro.
