GESTIONE FILE

GESTIONE FILE
Un file rappresenta un'astrazione fornita dal Sistema Operativo per permettere all'utente di operare sui supporti
di memoria secondaria. Nell'ambito della programmazione, ogni linguaggio, per poter essere definito tale, deve
fornire tra gli strumenti di base il supporto per operare sui file.
Per definizione, un file è una sequenza di byte; tutto ciò che un sistema di elaborazione può trattare (testo,
audio, video, immagini, programmi) può essere conservato in un file creato su un supporto di memoria
secondaria e caratterizzato da elementi quali: nome, dimensione, estensione, data, ora di creazione e permessi
(solo nei sistemi multiutente).
1 file assumono un'importanza fondamentale nello sviluppo di software gestionale, in quanto contribuiscono a
dare memoria alle applicazioni.
Anche se oggi l'organizzazione strutturata delle informazioni viene affidata a sistemi dedicati alla gestione di
basi di dati (vedi Mysql), la possibilità di operare direttamente sul singolo file può tornare utile anche nella
realizzazione di un sito web dinamico.
APERTURA E CHIUSURA FILE (FUNZIONI FOPEN E FCLOSE)
La funzione PHP preposta all'apertura o all'eventuale creazione di un file, è fopen. Di seguito ne viene indicata
la sintassi:
int fopen (string filename, string mode)
fopen è simile, nel nome e nel funzionamento, alla funzione corrispondente del C / C++.
La caratteristica che la contraddistingue è di fornire la possibilità di aprire connessioni remote, indicando come
filename un URL:
fopen("http://www.itis-cesena.it/pagina.html", "r")
fopen("ftp://username:[email protected]/prova.txt”,”w”)
Nel caso di connessioni HTTP, PHP inoltrerà al server remoto una richiesta di esecuzione di un metodo GET,
di conseguenza il file potrà essere soltanto letto. Al contrario, se si è utenti di un server FTP è possibile
utilizzare fopen per effettuare in remoto operazioni di lettura e scrittura (non contemporanee).
In questo caso la scrittura può essere rivolta soltanto alla creazione di nuovi file e non alla modifica di quelli
già esistenti.
Se l'operazione di apertura del fopen fallisce, fopen restituirà FALSE, in caso contrario ritornerà un numero
intero che dovrà essere utilizzato come parametro nelle successive operazioni di lettura o scrittura. Il parametro
mode indica la modalità di apertura del file, le costanti permesse sono:
r - Apre in sola lettura e posiziona il puntatore all'inizio del file.
r+ - Apre in lettura e scrittura e posiziona il puntatore all'inizio del file.
w - Apre il file in sola scrittura; posiziona il puntatore all'inizio del file azzerandone la lunghezza. Se il file non
esiste, tenta di crearlo
w+ - Apre in lettura e scrittura; posiziona il puntatore all'inizio del file azzerandone la lunghezza. Se il file non
esiste, tenta di crearlo.
a- Apre in sola scrittura; posiziona il puntatore alla fine del file. Se il file non esiste, tenta di crearlo.
a+ - Apre in lettura e scrittura; posiziona il puntatore alla fine del file. Se il file non esiste, tenta di crearlo.
Nei sistemi (quali ad esempio: Windows) che fanno differenza tra file binari e di testo, è necessario aggiungere
al parametro mode la costante "b", per indicare che si tratta di un file binario. Durante lo sviluppo delle vostre
applicazioni è sempre consigliato indicare questo distinguo, in modo da rendere l'applicazione portabile sia su
sistemi Windows che Unix in quanto, in quest’ultimi, la costante aggiunta al parametro mode sarà
completamente ignorata:
<?php
$fp = fopen(“img.gif","rb");
$fd = fopen(“testo.txt”,”w");
?>
Quando non viene indicato un URL per il parametro filename, il file sarà aperto, se esiste, dal server su cui si
trova in esecuzione lo script PHP. E’ possibile eventualmente indicare anche un path per il file.
In questo caso se Apache+PHP sono in esecuzione su una piattaforma Windows il carattere backslash (\)
causerebbe un errore di sintassi se non si provvedesse ad anteporvi il carattere di escape (\):
<?php
fopen("c:\\programmi\\EaSyPHP\\www\\prova.txtl,"w+")
?>
Nello specificare i possibili valori per il parametro mode, in alcuni casi è stato indicato il tentativo del PHP di
creare un file che non esiste. Si tratta di un tentativo, in quanto su sistemi operativi multiutente (quali Linux e
FreeBSD), spesso il server web, per motivi di sicurezza, viene associato ad un utente (nobody) senza alcun
privilegio di scrittura su disco. In questi casi, neanche un file già esistente può essere scritto se l'amministratore
del server non provvede a modificarne i permessi. Di conseguenza, se non amministrate un server Internet o
avete accesso in scrittura ad un server FTP, è più probabile che le funzioni sui file siano utilizzate in modalità
di lettura che non di scrittura. I file aperti tramite la funzione fopen possono essere chiusi tramite fclose.
Di seguito ne viene indicata la sintassi:
bool fclose (int fp)
La funzione fclose richiede in input il puntatore al file restituito da fopen, mentre assume come valore di ritorno
TRUE o FALSE per indicare se l'operazione è andata o meno a buon fine.
Nella stesura del codice è consigliato utilizzare sempre la funzione fclose per chiudere un file aperto con fopen,
anche se il PHP provvede a chiudere automaticamente tutti i file aperti al termine dell'esecuzione dello script.
<?php
$fp = fopen(“miofile.gif","rb”);
// … Operazioni varie
fclose($fp);
?>
FUNZIONI DI LETTURA
Tra le funzioni PHP che consentono di effettuare la lettura delle informazioni conservate in un file le più
utilizzate sono: fgets e fread.
fgets legge dal file length-1 byte se, un fine-linea (\n) oppure la fine del file (EOF) non viene raggiunta prima.
La sua sintassi è la seguente:
string fgets (int fp, int length)
Per mostrarne l'utilizzo, implementiamo uno script (leggi.php) che restituisce al browser la prima riga di un file
di testo (paroletxt) creato nella directory root nei documenti del server web:
parole.txt
------------ciao
a tutti
-------------leggi.php
<?php
$fp=fopen ("parole.txt",'r");
$c = fgets($fp, 10);
echo "<PRE>';
echo $c;
echo "sono stati letti ".strlen($c)." byte dal file</PRE>";
fclose($fp);
?>
L’esecuzione dello script, che in questo caso deve essere posizionato nella stessa directory in cui si trova il file,
genererà il seguente output:
ciao
sono stati letti 5 byte dal file
Come si può notare la lettura si è fermata al fine linea posizionato 4 caratteri dopo l'inizio del file.
Di seguito viene mostrato un classico script di esempio (come da manuale) che consente di leggere un file riga
per riga:
<?php
$fd = fopen ("parole.txt", "r");
while (!feof ($fd)) {
$riga = fgets($fd, 4096);
echo $riga;
}
fclose ($fd);
?>
La funzione fread, invece, legge length, byte dal file se, la fine del file (End-Of-File) non viene raggiunta
prima, salvaguardando così la corrispondenza binaria.
Di seguito ne viene indicata la sintassi:
string fread (int fp, int length)
Il seguente script mostra un esempio del suo utilizzo:
<?php
$nome = “prova”;
$fd=fopen("nomi.txt","rb");
$stringa = fread($fd, filesize("prova.txt"));
echo "la stringa: ".substr($stringa,strpos($stringa,$nome),strlen($nome))."è stata trovata";
fclose($fd);
?>
SCRITTURA E POSIZIONAMENTO
Anche in questo ambito la somiglianza con il C++ è evidente, infatti le due funzioni PHP che permettono di
effettuare operazioni di scrittura e di posizionamento del puntatore di un file sono: fwrite e fseek.
fwrite scrive su un file salvaguardando la corrispondenza binaria
int fwrite (int fp, string string [, int length])
La funzione fwrite scrive la sequenza di byte indicata da string all'interno del file puntato da fp. Il parametro
length, se presente, indicherà quanti byte della stringa devono essere scritti.
Se length dovesse essere più grande della lunghezza di string, la scrittura si arresterà quando sarà raggiunta la
fine della stringa.
<?php
$fp=fopen("testo.txt',"wb”);
fwrite($fp, “Ilsalve mondo”);
fclose($fp);
?>
fseek posiziona il puntatore del file
int fseek (int fp, int offset [, int whence])
La funzione fseek posiziona il puntatore del file a cui fa riferimento fp. Il puntatore sarà spostato di offset byte
rispetto ad una delle seguenti costanti permesse per il parametro whence:
SEEK_SET – inizio del file.
SEEK_CUR – posizione corrente.
SEEK_END – fine del file.
Whence è un parametro opzionale e se non viene specificato, di default sarà asunto SEEK_SEK.
Es.
Parole.txt
-------Ciao
A tutti
-------Test.php
<?php
$fp=fopen(“parole.txt”,”r”);
fseek($fp,8,SEEK_SET); // posiziona il puntatore all’8 byte dall’inizio del file
echo fgets($fp,10); // stampa a video la parola: tutti.
?>
ALTRE FUNZIONI UTILI
Æfile
Sintassi: array file(string filename [,int use_include_path])
Restituisce un array associativo dove ogni elemento corrisponde ad una riga del file
Æ filesize
Sintassi: int filesize(string filename);
Restituisce la dimensione di un file
Æ file_exists
Sintassi: bool file_exists (string filename)
Restituisce TRUE se filename esiste
Æ readfile
Sintassi: int readfile (string filename [, int use_include_path])
Legge un file e lo spedisce al browser. La funzione restituisce il numero di byte letti dal file.
Ipotizziamo di dover redirezionare gli utenti di www.vecchio.it verso il nuovo sito www.nuovosito.it.
Utilizzando la funzione readfile() si potrebbe implementare l’home page del vecchio sito come segue:
http://www.vecchio.it
index.php
<?php
readfile(“http://www.nuovosito.it/”);
?>
Æ unlink
int unlink(string filename)
Cancella un file
http://www.nuovosito.it
index.html
…..<center>Benvenuto</center>
<br><a href=http://www.nuovosito.it/continua.php>fai
click per entrare</a>….
SERIALIZZARE PER ARCHIVIARE STRUTTURE DATI
La funzione serialize() fornita dal linguaggio, rappresenta uno strumento molto potente e flessibile in quanto
può trasformare strutture dati molto complesse (oggetti inclusi) in un flusso di byte che può essere facilmente
conservato ovunque.
Sintassi: string serializza (mixed value)
Esempio:
Index.html
<FORM method=”POST” action=”scrivinews.php”>
Nickname <INPUT type=”TEXT” size=15 name=”nick”><br>
Email<INPUT type=”TEXT” size=15 name=”email”><BR>
Messaggio Breve<INPUT type=”TEXT” size=20 maxlength=100 name=”msg”><br>
<INPUT type=”SUBMIT” value=”OK”><br><br>
<a href=”legginew.php”>visualizza news</a>
</FORM>
L’esecuzione del form provocherà l’esecuzione dello script scrivinew.php
<?php
$news=array(“nick” => $_POST[“nick”], “email” => $_POST[“email”], “msg” => $_POST[“msg”], “data” =>
date(“j m y”),);
$fp=fopen(“news.txt”,”a”);
fwrite($fp,serialize($news));
fwrite($fp,”\n”);
fclose($fp);
echo “inserimento avvenuto con successo <hr>”;
….
?>
Gli input provenienti dal modulo web sono stati memorizzati prima in un array associativo che è stato poi
successivamente serializzato e memorizzato nel file news.txt.
Il codice poi inserisce un fine linea (\n) in modo tale che ad ogni esecuzione le news vengano memorizzate su
righe diverse.
Per leggere quello che abbiamo memorizzato nel file utilizziamo la funzione file(). Sviluppiamo lo script
legginews.php che avrà il compito di visualizzare le news precedentemente archiviate.
<?php
if (file_exists(“news.txt”))
{
$vet = file(“news.txt”);
echo“<TABLEborder=0 cellspacing=15>
<td>data</td></tr>”;
for($i=0; $i<count($vet);$i++)
{
$v=unserialize($vet[$i]);
echo “<tr><td>”.$v[“nick”].”</td>”;
echo “<tr><td>”.$v[“email”].”</td>”;
echo “<tr><td>”.$v[“msg”].”</td>”;
echo “<tr><td>”.$v[“data”].”</td></tr>”;
}
echo “</table>”;
}?>
<tr><td>nickname</td>
<td>email</td>
<td>messaggio</td>