Prima di provare a lavorare con il file, è consigliabile assicurarsi che esista. Due funzioni sono comunemente utilizzate per svolgere questo compito:
file_exists() e is_file().
La funzione f ilе_exists() verifica se il file specificato esiste. Se il file esiste, la funzione restituisce TRUE, altrimenti viene restituito FALSE. La sintassi per la funzione file_exists() è:
bool file_exists (file stringa)
Un esempio di verifica dell'esistenza di un file:
if (! file_exists ($ nomefile)):
print "File $ il nome del file non esiste!";
è_file()
La funzione is_file() verifica l'esistenza del file specificato e la capacità di eseguire operazioni di lettura/scrittura su di esso. In sostanza, is_file() è una versione più robusta di file_exists() che controlla non solo se un file esiste, ma anche se può leggere e scrivere dati:
bool is_file (file stringa)
L'esempio seguente mostra come verificare che un file esista e su cui sia possibile operare:
$ file = "un file.txt";
if (è_file ($ file)):
print "Il file $ file è valido ed esiste!";
print "Il file $ file non esiste o non è un file valido!";
Dopo essersi assicurati che il file richiesto esista e che sia possibile eseguire varie operazioni di lettura/scrittura con esso, è possibile procedere al passaggio successivo: l'apertura del file.
La funzione Filesize() restituisce la dimensione (in byte) del file con il nome specificato o FALSE in caso di errore. La sintassi per la funzione filesize() è:
int filesize (stringa nome file)
Supponiamo che tu voglia determinare la dimensione del file paste.txt. Puoi usare la funzione filesize() per ottenere le informazioni che desideri:
$ fs = dimensione del file ("pasticceria.txt"); print "Pastry.txt è $ fs byte.";
Viene visualizzato il seguente output:
Pastry.txt è di 179 byte.
Prima di poter eseguire operazioni su un file, è necessario aprirlo e associarlo all'handle del file e, dopo aver terminato di lavorare con il file, chiuderlo. Questi argomenti sono discussi nella sezione successiva.
Apertura e chiusura di file
Prima di eseguire operazioni di I/O su un file, è necessario aprirlo con la funzione fopen().
La funzione fopen() apre un file (se esiste) e restituisce un intero, il cosiddetto manipolatore di file(maniglia del file). La sintassi per la funzione fopen() è:
int fopen (file stringa, modalità stringa [, int enable_path])
Il file in fase di apertura può risiedere sul file system locale, esistere come flusso di I/O standard o presentare il file su un sistema remoto come ricevuto da HTTP o FTP.
Il parametro file può essere specificato in diverse forme, elencate di seguito:
Se il parametro contiene il nome di un file locale, fopen() apre quel file e restituisce un handle.
Se il parametro è specificato come php: // stdin, php: // stdout o php: // stderr, viene aperto il flusso di input/output standard corrispondente.
Se il parametro inizia con il prefisso http: //, la funzione apre una connessione HTTP al server e restituisce un handle per il file specificato.
Se il parametro inizia con il prefisso ftp: //, la funzione apre una connessione FTP al server e restituisce un handle per il file specificato. In questo caso, dovresti prestare particolare attenzione a due cose: se il server non supporta FTP passivo, la chiamata fopen() fallirà. Inoltre, i file FTP vengono aperti sia in lettura che in scrittura.
Quando si opera in modalità passiva, il server YR attende una connessione dal lato client. Quando si opera in modalità attiva, il server stesso stabilisce una connessione con il client. L'impostazione predefinita è solitamente la modalità attiva.
Il parametro mode determina la capacità di leggere e scrivere nel file. Tavolo 7.1 elenca alcuni dei valori che determinano la modalità di apertura di un file.
Tabella 7.1. Modalità di apertura dei file
| Modalità | Descrizione |
| Solo lettura. Il puntatore della posizione corrente è impostato all'inizio del file | |
| r + | Leggendo e scrivendo. Il puntatore della posizione corrente è impostato all'inizio del file |
| w | Scrivi solo. Il puntatore della posizione corrente viene impostato all'inizio del file e l'intero contenuto del file viene distrutto. Se il file non esiste, la funzione prova a crearlo |
| w + | Leggendo e scrivendo. Il puntatore della posizione corrente viene impostato all'inizio del file e l'intero contenuto del file viene distrutto. Se il file non esiste, la funzione prova a crearlo |
| un | Scrivi solo. Il puntatore della posizione corrente è posizionato alla fine del file. Se il file non esiste, la funzione prova a crearlo |
| un + | Leggendo e scrivendo. Il puntatore della posizione corrente è posizionato alla fine del file. Se il file non esiste, la funzione prova a crearlo |
Se il terzo parametro opzionale include_path è 1, il percorso del file è relativo alla directory di inclusione specificata nel file php.ini (vedi capitolo 1).
Di seguito è riportato un esempio di apertura di un file con la funzione fopen(). Die(), usato insieme a fopen(), fornisce un messaggio di errore se il file non può essere aperto:
$ file = "dati utente.txt"; // Alcuni file
$ fh = fopen ($ file, "a +") o die ("File ($ file) non esiste!");
Il seguente frammento apre una connessione a un sito PHP (http://www.php.net):
$ site = "http://www.php.net": // Server accessibile tramite HTTP
$ sh = fopen ($ sito., "r"); // Collega il manipolatore alla pagina dell'indice di php.net
Al termine, il file deve essere sempre chiuso con fclose().
La funzione fclose() chiude il file con l'handle specificato. Restituisce TRUE in caso di completamento con successo, FALSE in caso di errore. La sintassi per la funzione fclose() è:
int fclose (int manipolatore)
La funzione fclose() chiude correttamente solo quei file che erano stati precedentemente aperti con fopen() o fsockopen(). Esempio di chiusura di un file:
$ file = "dati utente.txt";
if (file_esiste ($ file)):
$ fh = fopen ($ file, "r");
// Esegue operazioni sui file
print "File Sfile non esiste!";
Scrivi su file
Ci sono due operazioni principali eseguite con i file aperti: lettura e scrittura.
La funzione is_writeable() consente di verificare che il file esista e sia scrivibile. La scrivibilità è verificata sia per il file che per la directory. La sintassi per la funzione is_writeable() è:
bool is_writeable (file stringa)
Un punto importante: molto probabilmente PHP verrà eseguito con l'ID utente utilizzato dal server web (di solito "nobody"). Per un esempio di utilizzo di is_writeable(), vedere la funzione fwrite().
La funzione fwrite() scrive il contenuto di una variabile stringa nel file specificato dall'handle del file. La sintassi per la funzione fwrite() è:
int fwrite (int manipolatore, variabile stringa [, int lunghezza])
Se il parametro di lunghezza opzionale viene passato nella chiamata di funzione, la registrazione si interrompe dopo che è stato scritto il numero di caratteri specificato o quando viene raggiunta la fine della riga. La verifica della capacità di scrivere su un file è dimostrata nell'esempio seguente:
// Informazioni sul traffico sul sito dell'utente
$ dati = "08: 13: 00 | 12: 37: 12 | 208.247.106.187 | Win98";
$ nomefile = "un file.txt";
// Se il file esiste e può essere scritto su
if (è_scrivibile ($ nomefile)):
$ fh = fopen ($ nomefile, "a +");
// Scrive il contenuto di $ data in un file
$ successo - fwrite ($ fh, $ dati);
//Chiudi file
fchiudi ($ fh); altro:
print "Impossibile aprire Sfilename per la scrittura";
La funzione fputs() è un alias per fwrite() e può essere usata ovunque venga usato fwrite().
La funzione fputs() è un alias per fwrite() e ha esattamente la stessa sintassi. La sintassi per la funzione fputs() è:
int fputs (int manipolatore, variabile stringa [, int lunghezza])
Personalmente preferisco usare fputs(). Tieni presente che questa è solo una questione di stile e non ha nulla a che fare con alcuna differenza tra le due funzioni.
Leggere da un file
La lettura è senza dubbio l'operazione più importante eseguita sui file. Di seguito sono descritte alcune delle funzionalità che rendono più efficiente la lettura da un file. La sintassi di queste funzioni copia quasi esattamente la sintassi di analoghe funzioni di scrittura.
La funzione i s_readable() assicura che il file esista e sia leggibile. La leggibilità è verificata sia per il file che per la directory. La sintassi per la funzione is_readable() è:
boo! è_leggibile (file stringa]
Molto probabilmente PHP verrà eseguito con l'ID utente utilizzato dal server Web (di solito "nobody"), quindi affinché is_readable() restituisca TRUE, è necessario consentire a tutti di leggere dal file. L'esempio seguente mostra come assicurarsi che un file esista e sia leggibile:
if (è_leggibile ($ nomefile)):
// Apri il file e imposta il puntatore della posizione corrente alla fine del file
$ fh = fopen ($ nomefile, "r");
print "$ il nome del file non è leggibile!";
La funzione fread() legge il numero di byte specificato dal file specificato dall'handle del file. La sintassi per la funzione fwrite() è:
int fread (int manipolatore, int lunghezza)
Il manipolatore deve fare riferimento a un file leggibile aperto (vedere la descrizione della funzione is_readable()). La lettura si interrompe quando è stato letto il numero di byte specificato o quando viene raggiunta la fine del file. Considera il file di testo paste.txt mostrato nel Listato 7.1. La lettura e la visualizzazione di questo file in un browser viene eseguita con il seguente frammento:
$ fh = fopen ("pastry.txt", "r") or die ("Non posso" aprire il file! ");
$ file = fread ($ fh, dimensione del file ($ fh));
Utilizzando la funzione fllesize() per determinare la dimensione di paste.txt in byte, ci si assicura che la funzione fread() legga l'intero contenuto del file.
Listato 7.1. File di testo Pastry.txt
Ricetta: pasta frolla
1 1/4 di tazza di farina per tutti gli usi
3/4 stick (6 cucchiai) di burro non salato, tritato
2 cucchiai di grasso vegetale 1/4 di cucchiaino di sale
3 cucchiai di acqua
La funzione fgetc() restituisce una stringa contenente un carattere dal file nella posizione corrente del puntatore o FALSE quando si raggiunge la fine del file. La sintassi per la funzione fgetc() è:
string fgetc (manipolatore int)
Il manipolatore deve fare riferimento a un file leggibile aperto (vedere la funzione is_readable() in precedenza in questo capitolo). L'esempio seguente mostra la lettura e l'output di un file carattere per carattere utilizzando la funzione fgetc():
$ fh = fopen ("pasticceria.txt", "r"); mentre (! feof ($ fh)):
$ carattere = fgetc ($ fh):
stampa $ carattere; alla fine;
La funzione fgets() restituisce la stringa letta dalla posizione corrente del puntatore nel file specificato dall'handle del file. Il puntatore del file deve puntare a un file leggibile aperto (vedere la funzione is_readable() in precedenza in questo capitolo). La sintassi per la funzione fgets() è:
string fgets (int manipolatore, int lunghezza)
La lettura si interrompe quando si verifica una delle seguenti condizioni:
- lunghezza letta da file - 1 byte;
- è stato letto un carattere di nuova riga dal file (incluso nella stringa restituita);
- un segno di fine file (EOF) è stato letto dal file.
Se vuoi organizzare la lettura riga per riga del file, passa nel secondo parametro un valore che ovviamente superi il numero di byte della riga. Un esempio di lettura riga per riga e output di un file:
$ fh = fopen ("pasticceria.txt", "r");
while (! feof ($ fh));
$ riga = fget ($ fh, 4096);
stampa la riga $. "
";
La funzione fgetss() è completamente simile a fgets() con un'eccezione: cerca di rimuovere tutti i tag HTML e PHP dal testo letto:
string fgetss (Int manipolatore, int length [, string allow_tags])
Prima di passare agli esempi, controlla il contenuto del Listato 7.2 — quel file è utilizzato nei Listati 7.3 e 7.4.
Listato 7.2. File Science.html
Scoperta forma di vita aliena
20 agosto 2000
Questa mattina presto, è stata trovata una strana nuova forma di fungo che cresceva nell'armadio del vecchio frigorifero dell'appartamento di W. J. Gilmore. Non è noto se le potenti radiazioni emanate dal monitor del computer dell'inquilino abbiano aiutato in questa evoluzione.
Listato 7.3. Rimuovi i tag dal file HTML prima di visualizzarli nel browser
$ fh = fopen ("science.html", "r");
mentre (! feof ($ fh)):
print fgetss ($ fh, 2048);
Il risultato è mostrato di seguito. Come puoi vedere, tutti i tag HTML sono stati rimossi dal file science.html, con conseguente perdita di formattazione:
In alcune situazioni, tutti i tag vengono rimossi dal file, tranne alcuni, ad esempio i tag di interruzione di riga
... Il Listato 7.4 mostra come farlo.
Listato 7.4. Rimuovi selettivamente i tag dal file HTML
$ fh = fopenC "science.html", "r");
$ consentito = "
";
mentre (! feof ($ fh)):
print fgetss ($ fh. 2048, $ consentito);
Risultato:
Breaking News - Scienza Forma di vita aliena scoperta il 20 agosto 2000 Questa mattina presto, è stata trovata una strana nuova forma di fungo che cresceva nell'armadio del vecchio frigorifero dell'appartamento di WJ Gilmore. Non è noto se le potenti radiazioni emanate dal computer dell'inquilino monitor aiutato in questa evoluzione.
Come puoi vedere, la funzione fgetss() semplifica la conversione dei file, specialmente se hai molti file HTML formattati in modo simile.
Lettura di un file in un array
La funzione file() carica l'intero contenuto di un file in un array indicizzabile. Ogni elemento dell'array corrisponde a una riga del file. La sintassi per la funzione file() è:
file array (file stringa [, int path_include])
Se il terzo parametro opzionale include_path è 1, il percorso del file è relativo alla directory di inclusione specificata nel file php.ini (vedi capitolo 1). Il Listato 7.5 usa la funzione file() per caricare il file paste.txt (vedi Listato 7.1).
$ file_array = file ("pasticceria.txt");
while (list ($ line_num. $ line) = eacht ($ file_array)):
stampa " Riga $ numero_linea:", htmlspecialchars ($ riga),"
\ n "
Ogni riga dell'array viene visualizzata insieme a un numero:
Riga 0: Ricetta: Pasta frolla
Linea 1: 1 1/4 tazze di farina per tutti gli usi
Linea 2: 3/4 stick (6 cucchiai) di burro non salato, tritato
Linea 3: 2 cucchiai di grasso vegetale
Riga 4: 1/4 di cucchiaino di sale
Riga 5: 3 cucchiai di acqua
Reindirizzare un file all'output standard
La funzione readfile() legge il contenuto di un file e lo indirizza allo standard output (nella maggior parte dei casi al browser). La sintassi per la funzione readfile() è:
int readfile (file di stringa [, int path_include])
La funzione restituisce il numero di byte letti. Il file può risiedere sul file system locale, esistere come flusso di I/O standard o rappresentare un file su un sistema remoto come ricevuto da HTTP o FTP. Il parametro file è impostato secondo le stesse regole della funzione fopen().
Supponiamo di avere un file latorre.txt che vuoi visualizzare nel browser:
Ristorante "La Torre". situato a Nettuno, in Italia, offre una miscela eclettica di stile. storia e buona cucina di mare. All'interno delle mura del borgo medievale che circonda la città, si può cenare guardando i passanti fare acquisti nelle boutique del paese. Il comfort abbinato solo al pesce più fresco fanno di La Torre uno dei migliori ristoranti d'Italia.
Quando viene eseguito il seguente frammento, tutti i contenuti di latorre.txt vengono reindirizzati al flusso di output standard:
$ file_ristorante = "latorre.txt";
// Invia l'intero file allo standard output
readfile ($ file_ristorante);
Apertura di un handle di file di processo
Insieme ai file normali, puoi aprire i manipolatori di file per interagire con i processi sul server. Il problema è risolto dalla funzione poren(), che ha la seguente sintassi:
int popen (comando stringa, modalità stringa)
Il parametro command definisce il comando di sistema da eseguire e il parametro mode descrive la modalità di accesso:
// Apri il file "spices.txt" per scrivere
$ fh = fopen ("spezie.txt", "w");
// Aggiungi più righe di testo
fputs ($ fh, "Prezzemolo, salvia, rosmarino \ n");
fputs ($ fh, "Paprika, sale, pepe \ n");
fputs ($ fh, "Basilico, salvia, zenzero \ n");
// Chiude il manipolatore
// Apri il processo grep di UNIX per trovare il basilico in spezie.txt
$ fh - popen ("grep Basil< spices.txt", "r");
// Stampa l'output di grep
Il risultato è simile a questo:
Basilico, salvia, zenzero
La funzione fpassthru() è analoga alla funzione passthru() discussa nella sezione "Esecuzione di programmi esterni" di questo capitolo.
Dopo aver completato tutte le operazioni, il file o il processo deve essere chiuso. La funzione pclose() chiude la connessione al processo specificato dal manipolatore, in modo simile a come la funzione fclose() chiude il file aperto dalla funzione fopen(). La sintassi per la funzione pclose() è:
int pclose (int manipolatore)
Nel parametro manipolatore il manipolatore ricevuto in precedenza da una chiamata riuscita a poren() viene passato.
Apertura di una connessione presa
PHP non si limita all'interazione con file e processi: puoi anche stabilire connessioni tramite socket. Presa(socket) è un'astrazione software che consente la comunicazione con vari servizi su un altro computer.
La funzione fsockopen() stabilisce una connessione socket a un server su Internet
tramite TCP o UDP. La sintassi per la funzione fsockopen() è:
int fsockopen (string node, int port [, int error_code [, string error_text [, int timeout]]])
I parametri facoltativi codice_errore e testo_errore contengono informazioni che verranno visualizzate se la connessione al server non riesce. Entrambi i parametri devono essere passati per riferimento. Il terzo parametro facoltativo, timeout, specifica il tempo di attesa di una risposta dal server (in secondi). Il Listato 7.6 mostra come usare fsockopen() per ottenere informazioni su un server. Tuttavia, prima di esaminare il Listato 7.6, è necessario acquisire familiarità con un'altra funzione, socket_set_blocking().
UDP (User Datagram Protocol) è un protocollo di comunicazione senza connessione.
socket_set_blocking()
La funzione Socket_set_b1ocki ng() consente di impostare il controllo del timeout per le operazioni del server:
socket_set_blocking (manipolatore int, modalità booleana)
Il parametro manipolatore specifica un socket aperto in precedenza e il parametro mode specifica la modalità in cui è commutato il socket (TRUE per la modalità di blocco, FALSE per la modalità non di blocco). Un esempio di utilizzo delle funzioni fsockopen() e socket_set_blocking() è mostrato nel Listato 7.6.
Listato 7.6. Utilizzo della funzione fsockopen() per ottenere informazioni sul server
funzione getthehost ($ host. $ percorso) (
// Apre una connessione a un nodo
$ fp - fsockopen ($ host, 80, & $ errno, & $ errstr, 30);
// Passa alla modalità di blocco
socket_set_blocking ($ fp, 1),
// Invia intestazioni
fputs ($ fp, "OTTIENI $ percorso HTTP / 1.1 \ r \ n");
fputs ($ fp, "Host: $ host \ r \ n \ r \ n"); $ x = 1;
// Ottieni le intestazioni
mentre ($ x< 10) :
$ intestazioni = fget ($ fp, 4096);
// Chiude il manipolatore
getthehost ("www.apress.com", "/");
Il Listato 7.6 produce il seguente output:
НТТР / 1.1 200 OK Server: Microsoft-IIS / 4.0 Posizione contenuto:
2000 20:25:06 GMT ETag: "f0a61666dbff1bf1: 34a5" Lunghezza contenuto: 1311
La funzione pfsockopen() è una versione persistente di fsockopen(). Ciò significa che la connessione non verrà terminata automaticamente al termine dello script in cui è stata chiamata la funzione. La sintassi per la funzione pfsockopen() è:
int pfsockopen (string node, int port [, int error_code [, string text_error [, int timeout]]])
A seconda dello scopo specifico della tua applicazione, potrebbe essere più conveniente usare pfsockopen() invece di fsockopen().
Avvio di programmi esterni
Gli script PHP possono anche eseguire programmi che risiedono sul server. Questa funzione viene utilizzata particolarmente spesso quando si amministra il sistema tramite un browser Web, nonché per ottenere più comodamente informazioni di riepilogo sul sistema.
La funzione exec() avvia il programma specificato e restituisce l'ultima riga del suo output. La sintassi per la funzione exec() è:
string exec (string command [, string array [, int return]])
Nota: la funzione exec() esegue solo il comando, senza visualizzare i risultati del suo lavoro. Tutto l'output del comando può essere memorizzato nell'array di parametri opzionale. Inoltre, se viene specificata anche la variabile di ritorno per il dato array di parametri, a quest'ultimo viene assegnato il codice di ritorno del comando eseguito.
Il Listato 7.7 mostra come utilizzare la funzione exec() per eseguire la funzione ping del sistema UNIX.
Listato 7.7. Verifica della connessione con il server utilizzando la funzione exec()
exec ("ping -c 5 www.php.net", $ ping);
// Su Windows - exec ("ping -n 5 www.php.net. $ Ping);
per ($ i = 0; $ i< count($ping);$i++) :
stampa "
$ ping [$ i] ";
Risultato:
PING www.php.net (208.247.106.187): 56 byte di dati
64 byte da 208.247.106.187: icmp_seq = 0 ttl = 243 time = 66.602 ms
64 byte da 208.247.106.187: icmp_seq = 1 ttl = 243 time = 55.723 ms
64 byte da 208.247.106.187: icmp_seq = 2 ttl = 243 time = 70.779 ms
64 byte da 208.247.106.187: icmp_seq = 3 ttl = 243 time = 55.339 ms
64 byte da 208.247.106.187: icmp_seq = 4 ttl = 243 time = 69.865 ms
Statistiche di ping di Www.php.net -
5 pacchetti trasmessi. 5 pacchetti ricevuti. 0% di perdita di pacchetti
andata e ritorno min / media / max / stddev - 55.339 / 63.662 / 70.779 / 6.783 ms
Backtick
Esiste un altro modo per eseguire comandi di sistema che non richiede funzioni di chiamata: il comando in esecuzione è racchiuso tra apici inversi (``) e i risultati del suo lavoro vengono visualizzati nel browser. Esempio:
stampa "
$ uscita";
Questo frammento restituisce al browser il contenuto della directory contenente lo script.
Il parametro interno ping -c 5 (-n 5 su Windows) specifica il numero di interrogazioni del server.
Se vuoi solo restituire i risultati non formattati di un comando, usa la funzione passthru() descritta di seguito.
La funzione passthru() funziona più o meno allo stesso modo di exec(), con un'eccezione: stampa automaticamente l'output del comando. La sintassi per la funzione passthru() è:
void passthru (string command [, int return])
Se viene passato un parametro di ritorno facoltativo quando si chiama passthru(), a questa variabile viene assegnato il codice di ritorno del comando eseguito.
escapeshellcmd()
La funzione escapeshellcmd() esegue l'escape di tutti i caratteri potenzialmente non sicuri che l'utente potrebbe immettere (ad esempio, in un modulo HTML) per eseguire i comandi exec(), passthru(), system() o poverien(). Sintassi:
stringa escapeshellcmd (comando stringa)
L'input dell'utente deve essere sempre trattato con una certa cautela, ma anche in questo caso gli utenti possono immettere comandi che verranno eseguiti dalle funzioni di avvio dei comandi di sistema. Considera il seguente frammento:
$ input_utente = `rm -rf *`; // Rimuove la directory padre e tutte le sue sottodirectory
exec ($ user_input); // Esegui $ user_input !!!
Se non vengono prese precauzioni, un tale comando porterà al disastro. Tuttavia, puoi usare le funzioni escapeshellcmd() per sfuggire all'input dell'utente:
$ input_utente = `rm - rf *`; // Rimuove la directory padre e tutte le sue sottodirectory
exec (escapeshellcmd ($ user_input)); // Fuga da personaggi pericolosi
La funzione escapeshellcmd() esegue l'escape del carattere * per impedire l'esecuzione catastrofica del comando.
La sicurezza è uno degli aspetti più importanti della programmazione web, quindi ho dedicato un intero capitolo a questo argomento e alla sua relazione con la programmazione PHP. Per maggiori informazioni vedere il capitolo 16.
Lavorare con il file system
PHP fornisce funzioni per visualizzare ed eseguire varie operazioni sui file sul server. Le informazioni sugli attributi dei file del server (posizione, proprietario e privilegi) sono spesso utili.
La funzione basename() estrae il nome del file dal nome completo fornito. La sintassi per la funzione nomebase() è:
stringa basename (stringa nome_completo)
L'estrazione del nome del file di base dal nome completo è la seguente:
$ percorso = "/usr/local/phppower/htdocs/index.php"; $ file = nome base ($ percorso); // $ file = "index.php"
Infatti, questa funzione rimuove il percorso dal nome completo e lascia solo il nome del file.
La funzione getlastmod() restituisce la data e l'ora dell'ultima modifica della pagina da cui viene chiamata la funzione. La sintassi per la funzione getlastmod() è:
int getlastmod (vuoto)
Il valore restituito è in formato data/ora UNIX e può essere formattato utilizzando la funzione date(). Il seguente frammento mostra la data dell'ultima modifica della pagina:
echo "Ultima modifica:" .date ("H: i: s a". getlastmod ());
La funzione stat() restituisce un array indicizzabile con informazioni dettagliate sul file con il nome dato:
array stat (stringa nome file)
Le seguenti informazioni vengono restituite negli elementi dell'array:
0 Costruzione
2 Modalità di protezione inode
3 Numero di collegamenti
4 ID utente proprietario
5 ID gruppo proprietario
6 Tipo di dispositivo inode
7 Dimensione in byte
8 Ora dell'ultimo accesso
9 Ora dell'ultima modifica
10 Ora dell'ultima modifica
11 Dimensione del blocco per I/O nel file system
12 Numero di blocchi allocati
Pertanto, se si desidera conoscere l'ora dell'ultimo accesso al file, fare riferimento all'elemento 8 dell'array restituito. Consideriamo un esempio:
$ file - "filedati.txt";
list ($ dev, $ inode, $ inodep, $ nlink, $ uid, $ gid, $ inodev, $ size, $ atime, $ mtime, $ ctime,
$ bsize) = stat ($ file);
print "$ il file ha una dimensione di $ in byte.
";
print "Ora dell'ultimo accesso: $ atime
";
print "Ora dell'ultima modifica: $ mtime
";
Risultato:
popen.php è di 289 byte.
Orario ultimo accesso: 15 agosto 2000 12:00:00
Ora dell'ultima modifica: 15 agosto 2000 10:07:18
In questo esempio, ho usato il costrutto list() per denominare ogni valore restituito. Naturalmente, puoi anche restituire un array, scorrere gli elementi in un ciclo e visualizzare tutte le informazioni necessarie. Come puoi vedere, la funzione stat() fornisce varie informazioni utili su un file.
Visualizzazione e modifica delle caratteristiche dei file
Ogni file sui sistemi UNIX ha tre caratteristiche importanti:
- appartenenza a un gruppo;
- proprietario;
- autorizzazioni.
Tutte queste caratteristiche possono essere modificate utilizzando le apposite funzioni PHP. Le funzionalità descritte in questa sezione non funzionano sui sistemi della famiglia Windows.
Se non si conoscono i sistemi operativi UNIX, è possibile ottenere informazioni sulle specifiche del file system UNIX da http://sunsite.auc.dk/linux-newbie/FAQ2.htm. Gli argomenti dell'appartenenza al gruppo, della proprietà e dei permessi sono discussi nella sezione 3.2.6.
La funzione chgrp() tenta di modificare il gruppo a cui appartiene il file specificato. La sintassi per la funzione chgrp() è:
int chgrp (nome file stringa, gruppo misto)
La funzione filegroup() restituisce l'ID di gruppo del proprietario del file con il nome specificato o FALSE in caso di errore. La sintassi per la funzione filegroup() è:
int filegroup (stringa nome file)
La funzione chmod() cambia i permessi del file con il nome dato. La sintassi per la funzione chmod() è:
int chmod (stringa nomefile, int permessi)
I permessi sono in ottale. Le specifiche dell'impostazione di un parametro per la funzione chmod() sono illustrate nell'esempio seguente:
chmod ("file_dati.txt", g + r); // Non funziona
chmod ("file_dati.txt", 766); // Non funziona
chmod ("file_dati.txt", 0766); // Lavorando
La funzione fileperms() restituisce i permessi del file con il nome specificato o FALSE in caso di errore. La sintassi per la funzione fileperms() è:
int fileperms (stringa nome file)
La funzione chown() cerca di cambiare il proprietario di un file. Solo l'utente privilegiato ha il diritto di modificare il proprietario di un file. La sintassi per la funzione chown() è:
int chown (nome file stringa, utente misto)
La funzione fileowner() restituisce l'ID utente del proprietario del file con il nome specificato. La sintassi per la funzione fileowner() è:
int fileowner (stringa nome file)
Copiare e rinominare file
Altre utili funzioni di sistema che gli script PHP possono eseguire includono la copia e la ridenominazione dei file sul server. Queste operazioni vengono eseguite da due funzioni: litter() e rename().
Copiare un file in uno script PHP non è più difficile che usare il comando UNIX cfr. Il compito è risolto dalla funzione PHP sopu(). La sintassi per la funzione copu() è:
int copy (origine stringa, destinazione stringa)
La funzione copu() tenta di copiare il file di origine nel file di destinazione; restituisce TRUE in caso di successo e FALSE in caso di fallimento. Se il file di destinazione non esiste, la funzione litter() lo crea. L'esempio seguente mostra come eseguire il backup di un file utilizzando la funzione copu():
$ data_file = "datal.txt";
copy ($ data_file. $ data_file ".bak") o die ("Impossibile copiare $ data_file");
La funzione rename() rinomina un file. Restituisce TRUE in caso di successo e FALSE in caso di fallimento. La sintassi per la funzione rename() è:
bool rename (stringa vecchio_nome, stringa nuovo_nome)
Un esempio di ridenominazione di un file con la funzione rename():
$ data_file = "datal.txt";
rename ($ file di dati, $ file di dati ".old") o die ("Impossibile rinominare $ file di dati");
Eliminazione di file
La funzione unlink() rimuove il file con il nome dato. Sintassi:
int unlink (file di stringa)
Se utilizzi PHP su un sistema Windows, a volte sorgono problemi durante l'utilizzo di questa funzione. In questo caso, puoi usare la funzione system() sopra descritta ed eliminare il file con il comando DOS del:
sistema ("del filename.txt");
Lavorare con le directory
Le funzioni PHP consentono di visualizzare e navigare nei contenuti delle directory. Il Listato 7.8 mostra una tipica struttura di directory UNIX.
Listato 7.8. Tipica struttura di directory
La funzione dirname() integra basename() per estrarre il percorso dal nome file completo. La sintassi per la funzione dirname() è:
stringa dirname (percorso stringa)
Un esempio dell'utilizzo di dirname() per estrarre un percorso da un nome completo:
$ percorso = "/usr/locla/phppower/htdocs/index.php";
$ file = nome dir ($ percorso); // $ file = "usr/local/phppower/htdocs"
La funzione dirname() viene talvolta utilizzata insieme alla variabile $ SCRIPT_FILENAME per ottenere il percorso completo dello script da cui viene eseguito il comando:
$ dir - nome dir ($ SCRIPT_FILENAME);
La funzione is_dir() controlla se il file con il nome dato è una directory:
bool is_dir (stringa nome file)
L'esempio seguente utilizza la struttura di directory del Listato 7.8:
$ isdir = is_dir ("index.html"); // Restituisce FALSO
$ isdir = is_dir ("libro"); // restituisce VERO
La funzione mkdir() fa lo stesso del comando UNIX con lo stesso nome: crea una nuova directory. La sintassi per la funzione mkdir() è:
int mkdir (percorso stringa, modalità int)
Il parametro path definisce il percorso per la creazione di una nuova directory. Non dimenticare di terminare il parametro con il nome della nuova directory! Il parametro mode determina i permessi da assegnare alla directory creata.
Proprio come la funzione fopen() apre un manipolatore per manipolare il file specificato, la funzione opendir() apre un manipolatore per manipolare una directory. La sintassi per la funzione opendir() è:
int opendir (percorso stringa)
La funzione closedir() chiude l'handle di directory passato come parametro. La sintassi per la funzione closedir() è:
void closedir (int dir_manipulator)
La funzione readdir() restituisce la voce successiva nella directory specificata. Sintassi:
stringa readdir (int dir_manipulator)
Con questa funzione, puoi facilmente elencare tutti i file e le sottodirectory nella directory corrente:
$ dh = opendir (".);
while ($ file = readdir ($ dh)):
stampa "$ file
"; alla fine;
La funzione chdir() funziona come il comando UNIX cd — naviga nella directory specificata dal parametro. La sintassi per la funzione chdir() è:
int chdir (directory delle stringhe)
Nell'esempio seguente, andiamo al libro/sottodirectory e ne visualizziamo il contenuto:
$ newdir = "libro";
chdir ($ newdir) o die ("Impossibile passare alla directory ($ newdir)"); $ dh = opendir (".");
while ($ file = readdir ($ dh));
stampa "$ file
";
La funzione rewlnddir() sposta il puntatore della posizione corrente all'inizio della directory aperta dalla funzione opendir(). La sintassi per la funzione rewinddir() è:
void rewinddir (int dir_nip)
Progetto 1: un semplice contatore di visite
Lo script presentato in questa sezione conta il numero di accessi alla pagina in cui si trova. Prima di passare al codice nel Listato 7.9, rivedi l'algoritmo dello pseudocodice:
- Imposta la variabile di accesso $ sul nome del file in cui verrà memorizzato il valore del contatore.
- Utilizzare la funzione file() per leggere il contenuto di $ access nell'array $ visits. Il prefisso @ davanti al nome della funzione elimina possibili errori (ad esempio, l'assenza di un file con il nome specificato).
- Imposta la variabile $ current_visitors sul primo (e unico) elemento nell'array $ visits.
- Aumenta il valore di $ current_visitors di 1.
- Apri il file $ access per la scrittura e imposta il puntatore della posizione corrente all'inizio del file.
- Scrivi il valore di $current_visitors nel file $ access.
- Chiudi l'handle che fa riferimento a $ access.
Listato 7.9. Contatore di colpi semplice
// Scenario: contatore di colpi semplice
// Scopo: salvare il numero di hit nel file
$ access = "hits.txt"; // Il nome del file è scelto arbitrariamente
$ current_visitors = $ visite; // Recupera il primo (e unico) elemento
++ $ current_visitors; // Aumenta il contatore di colpi
$ fh = fopen ($ access. "w"); // Apri il file hits.txt e installa
// puntatore della posizione corrente all'inizio del file
@fwrite ($ fh, $ current_visitors); // Scrivi il nuovo valore del contatore
// nel file "hits.txt"
fchiudi ($ fh); // Chiude l'handle del file "hits.txt"
Progetto 2: costruzione di una mappa del sito
Lo script nel Listato 7-10 crea una mappa del sito, una vista gerarchica di tutte le cartelle e i file sul server, a partire da una determinata directory. Nel calcolo dell'indentazione degli elementi che compongono la mappa del sito vengono utilizzate le funzioni definite in questo e nei capitoli precedenti. Prima di passare al programma, rivedi l'algoritmo scritto in pseudocodice:
- Dichiarare le variabili di servizio per memorizzare la directory padre, il nome del file grafico con l'immagine della cartella, il nome della pagina e il flag del sistema operativo del server (Windows o altro sistema).
- Dichiarare la funzione display_directory() che legge il contenuto della directory e lo formatta per la visualizzazione nel browser.
- Costruisci il percorso della directory concatenando il nome passato nella variabile $ dir1 con $ dir.
- Apri la directory e leggi il suo contenuto. Formattare directory e nomi di file e visualizzarli nel browser.
- Se il file corrente è una directory, chiama ricorsivamente la funzione rectory() di display_di e passagli il nome della nuova directory da visualizzare. Calcola il rientro utilizzato durante la formattazione dell'output.
Se il file non è una directory, viene formattato per essere visualizzato come collegamento ipertestuale (e viene calcolata anche l'indentazione utilizzata per la formattazione).
Listato 7.10. Programma Sitemap.php
// File: sitemap.php
// Scopo: costruire una mappa del sito
// Directory da cui iniziare a costruire la mappa
$ beg_path = "C: \ Program FilesVApache Group \ Apache \ htdocs \ phprecipes";
// File con un'immagine grafica della cartella.
// Il percorso deve essere impostato Relativo a * la directory principale del server Apache
$ folder_location = "C: \ Documenti \ PHP per programmatori \ FINAL CHPS \ graphics \ folder.gif";
// Testo nel titolo della finestra $ page_name = "PHPRecipes SiteMap";
// Lo script verrà utilizzato su Linux o Windows?
// (0 - Windows; 1 - Linux)
$ usingjinux = 0;
// Funzione: directory_display
// Scopo: leggere il contenuto della directory specificata dal parametro
// $ dir1, seguito dalla formattazione della directory e dalla gerarchia dei file.
// La funzione può essere chiamata ricorsivamente.
funzione display_directory ($ dir1, $ folder_location, $ using_linux, $ init_depth) (
// Aggiorna percorso
Sdh = opendir ($ dir);
while ($ file = readdir ($ dh)):
// Elementi della directory "." e ".." non vengono visualizzati.
if (($ file! = ".") && ($ file! = "..")):
if ($ using_linux == 0):
$ profondità = esplode ("\\", $ dir): else:
$ profondità = esplodi ("/", $ dir); finisci se; $ curtent_depth = sizeof ($ profondità);
// Costruisce il percorso secondo le regole del sistema operativo utilizzato. if ($ using_linux == 0):
$ tab_depth = $ current_deptn - $ init_depth;
$ file = $ directory. "\\", $ file; altro:
$ file = $ directory. "/", $ file; finisci se;
// La variabile $ file contiene una directory? if (è dir ($ file)):
// Calcola rientro
mentre ($ x< ($tab_depth * 2)) :
$ x++; alla fine;
stampa "
".nomebase (file $)."
";
// Aumenta il contatore
// Chiama ricorsivamente la funzione display_directory()
display_directory ($ file, $ posizione_cartella, $ using_linux, $ init_depth);
// Lui directory
// Costruisci il percorso secondo le regole usate
// sistema operativo.
if ($ using_linux == 0):
$ tab_depth = ($ current_depth - $ init_depth) - 2; $ x = 0;
// Calcola rientro
mentre ($ x< (($tab_depth * 2) + 5)) :
stampa " ".nomebase (file $)."
";
stampa " ".nomebase (file $)."
";
finisci se; // Is_dir (file) endif: // If! "." o ".."
// Chiude la directory closedir ($ dh);
// Calcola il riempimento iniziale
if ($ using_linux == 0):
$profondità = esplode ("\\", $ beg_path);
$ profondità = esplodi ("/", $ percorso_inizio);
$ init_depth = sizeof ($ profondità);
display_directory ($ beg_path, $ folder_location, $ using_linux, $ init_depth);
Nella fig. 7.1 mostra l'output di uno script per una directory con diversi capitoli in questo libro.
Riso. 7.1. Visualizzazione della struttura della directory sul server utilizzando lo script sitemap.php
risultati
Questo capitolo ha introdotto molti degli strumenti PHP per lavorare con i file. Nello specifico, abbiamo esaminato i seguenti problemi:
- verifica dell'esistenza di file;
- apertura e chiusura di file e flussi di I/O;
- scrivere e leggere da un file;
- reindirizzare un file a un flusso di output;
- lanciare programmi esterni;
- operazioni del file system.
Questo capitolo ha posto le basi per il capitolo successivo, "Stringhe ed espressioni regolari", perché la gestione delle stringhe e l'I/O sono strettamente correlati nello sviluppo web.
In realtà, l'apertura di un file php non è un grosso problema. Può essere più difficile aprire una bottiglia di birra quando sei in mezzo alla foresta. Ma solo i programmatori accaniti la pensano così. E per i principianti, ti parleremo di tutte le possibilità di php per lavorare con i file:
File php
I file con estensione php contengono codice scritto nel linguaggio di programmazione con lo stesso nome. A differenza di altri linguaggi, php è un linguaggio di programmazione lato server. Cioè, funziona sul lato server. Pertanto, per eseguire il debug del suo codice, è necessario installare un server locale sulla macchina client.
Per lavorare con i file php, vengono utilizzate applicazioni speciali: editor di software. I più comuni sono:
- Tessitore di sogni.
- PHPModifica.
- Sviluppo PHP di Eclipse.
Quando si creano siti basati su php, potrebbe essere necessario riutilizzare il codice del programma. In tali situazioni, è conveniente includere soluzioni già pronte che si trovano in un altro file. Il costrutto include viene utilizzato per questo. La sua sintassi è:
includi nome file
Esempio di collegamento:
File incluso:
È anche possibile includere un file utilizzando il costrutto require. A differenza di include, include il file prima dell'esecuzione del codice del programma. Con l'aiuto di require nel codice, è possibile solo una chiamata a questo file. Se lo richiami, il sistema emetterà un messaggio di errore globale e interromperà l'esecuzione del programma.
Il costrutto include include l'origine solo durante l'esecuzione del programma. Supporta la lettura multipla di file php. Se si verifica un errore, verrà visualizzato solo un messaggio di avviso e l'esecuzione del codice continuerà dalla riga successiva.
Apertura e chiusura di file
In php, tutte le operazioni con i file vengono eseguite in più fasi:
- Apertura di un file;
- Modifica dei contenuti;
- Chiusura del file.
La funzione fopen() viene utilizzata per aprire il file. La sua sintassi è:
int fopen (string nome file, modalità stringa [, int use_include_path])
Argomenti accettati:
- stringa nome file - nome file o percorso assoluto ad esso. Se il percorso del file non è specificato, verrà cercato nella directory corrente. Se il file che stai cercando non è presente, il sistema visualizzerà un messaggio di errore. Esempio:
- string mode - indica la modalità di apertura del file. Valori accettati dall'argomento:
- r - il file è aperto in sola lettura, il puntatore del file è impostato all'inizio;
- r + - il file è aperto per la lettura e la scrittura;
- w - Crea un nuovo file di sola scrittura. Se esiste già un file con lo stesso nome, tutti i dati vengono automaticamente eliminati al suo interno;
- w + - viene creato un nuovo file per la scrittura e la lettura. Se tale file esiste, i suoi dati vengono completamente sovrascritti con quelli nuovi;
- a - il file è aperto per la scrittura. Il puntatore è posizionato alla fine. Cioè, la scrittura nel file php non partirà dall'inizio, ma dalla fine;
- un + - apre il file in modalità lettura e scrittura. La registrazione partirà dalla fine;
- b - la modalità di lavoro con un file contenente dati binari (nel sistema binario di calcolo). Questa modalità è disponibile solo sul sistema operativo Windows.
Per chiudere l'accesso a un file, utilizzare la funzione fclose(). Sintassi:
int fclose (file int), dove file int è il descrittore del sito da chiudere.
Dopo ogni lettura o scrittura, il file deve essere chiuso con questa funzione. In caso contrario, il flusso creato per il file rimane aperto. E questo porta a un consumo non necessario delle capacità del server.
Esempio:
Lettura e scrittura di file
La funzione readfile() è ideale per visualizzare semplicemente l'intero contenuto di un file. La sua sintassi è:
readfile (stringa nomefile), dove stringa nomefile è la stringa nomefile (non un descrittore).
int fpassthru (file int)
La funzione richiede l'apertura e la chiusura di un file. Esempio:
Il risultato è simile al precedente.
Le funzioni per lavorare con i file in php consentono di leggere il contenuto riga per riga e carattere per carattere:
- string fgets (file int, lunghezza int)- la funzione legge una stringa di lunghezza lunghezza. Esempio:
- string fread (file int, lunghezza int)- l'azione è identica alla precedente.
Ci sono due funzioni identiche per scrivere dati di testo in un file:
- int fputs (file int, string string [, int length])
- int fwrite (file int, stringa stringa [, lunghezza int])
Le funzioni scrivono nel file int file una stringa stringa stringa della lunghezza specificata int length ( argomento opzionale). Esempio:
Creazione ed eliminazione di file
Per creare un file php, puoi utilizzare la funzione fopen() in modalità di accesso "w" o "w +". Oppure la funzione touch (). Imposta l'ora di modifica per il file. Se non è presente alcun elemento con il nome richiesto, verrà creato. La sua sintassi è:
int touch (string nomefile [, int time [, int atime]])
La funzione copy() viene utilizzata per creare una copia del file. Accetta il nome dell'originale e il file in cui copiare il contenuto come argomenti. Se non esiste, verrà creato. Sintassi della funzione:
int copy (file stringa1, file stringa2)
È possibile eliminare un file utilizzando la funzione unlink (). La sua sintassi.
Utilizzo delle funzioni fopen, fclose, feof, fgets, fgetss e fscanf
Elenchiamo tutte le possibilità
Uno dei vantaggi di lavorare con linguaggi di programmazione moderni come PHP è l'enorme quantità di funzionalità disponibili. PHP avrebbe potuto facilmente adottare il motto Perl, "Ci sono molti modi per fare qualcosa", specialmente quando si tratta di gestire i file. Ma con la pletora di fondi disponibili, sorge la domanda su quale sia il migliore per portare a termine il lavoro. Naturalmente, in realtà, la risposta a questa domanda dipende dagli obiettivi che ti poni durante l'elaborazione del file, quindi vale la pena imparare tutte le funzionalità della lingua.
Metodi tradizionali di fopen
I metodi fopen sono forse più familiari ai programmatori C e C++ dei vecchi tempi, in quanto sono, in misura maggiore o minore, esattamente gli strumenti che sono stati a portata di mano per molti anni se hai lavorato con questi programmi le lingue. Per ognuno di questi metodi, segui una procedura standard, usando fopen per aprire il file, una funzione per leggere i dati e quindi fclose per chiudere il file, come mostrato nel Listato 1.
Listato 1. Apertura e lettura di un file con fgets
$ file_handle = fopen ("miofile", "r"); while (! feof ($ file_handle)) ($ line = fgets ($ file_handle); echo $ line;) fclose ($ file_handle);Sebbene queste funzioni siano familiari ai programmatori più esperti, permettetemi di analizzare come funzionano. In realtà, stai seguendo questi passaggi:
- Apri il file. $ file_handle memorizza un collegamento al file stesso.
- Controlla se hai raggiunto la fine del file.
- Continua a leggere il file fino alla fine, stampando ogni riga che leggi.
- Chiudi il file.
Con questo in mente, esaminerò ogni funzione file utilizzata qui.
Funzione Fopen
La funzione fopen stabilisce un collegamento a un file. Dico "si connette" perché, oltre ad aprire un file, fopen può anche aprire un URL:
$ fh = fopen ("http://127.0.0.1/", "r");Questa riga di codice crea un collegamento alla pagina precedente e consente di iniziare a leggerla come file locale.
Nota: Il parametro "r" utilizzato in fopen indica che il file è aperto in sola lettura. Poiché scrivere su un file va oltre lo scopo di questo articolo, non elencherò tutti i possibili valori del parametro. Tuttavia, devi cambiare "r" in "rb" se stai leggendo da binari per la compatibilità multipiattaforma. Di seguito verrà fornito un esempio di questo tipo.
Funzione Feof
Il comando feof determina se è stata effettuata una lettura fino alla fine del file e restituisce True o False. Il ciclo indicato continua fino alla fine del file "myfile". Nota che feof restituisce False anche se stai leggendo un URL e la connessione è scaduta perché non ci sono più dati da leggere.
Funzione Fclose
Salta la metà del Listato 1 e vai alla fine; fclose fa l'opposto di fopen: chiude la connessione a un file o URL. Dopo aver eseguito questa funzione, non sarai più in grado di leggere da un file o da un socket.
Funzione Fget
Tornando indietro di alcune righe nel Listato 1, sei proprio nel cuore del processo di gestione dei file: la lettura diretta del file. La funzione fgets è la tua "arma" preferita per il primo esempio. Prende una riga di dati da un file e la restituisce come stringa. Da lì, puoi emettere dati o elaborarli in altro modo. L'esempio nel Listato 1 stampa l'intero file.
Se decidi di limitare la dimensione del blocco di dati su cui stai lavorando, puoi aggiungere un argomento a fgets per limitare la lunghezza massima della linea dati acquisita. Ad esempio, utilizzare il codice seguente per limitare la lunghezza della stringa a 80 caratteri:
$ stringa = fgets ($ file_handle, 81);Pensa a "\ 0", la fine della riga in C, e imposta la lunghezza su un carattere in più di quello di cui hai effettivamente bisogno. Come puoi vedere, l'esempio sopra usa 81, mentre hai bisogno di 80 caratteri. Prendi l'abitudine di aggiungere un carattere extra ogni volta che devi impostare un limite di lunghezza della stringa per una determinata funzione.
Funzione Fread
La funzione fgets è solo una delle tante funzioni disponibili per leggere un file. Questa è una delle funzioni più comunemente utilizzate, poiché l'elaborazione riga per riga di un file è più sensata nella maggior parte dei casi. In effetti, molte altre funzionalità offrono funzionalità simili. Tuttavia, l'analisi riga per riga non è sempre ciò che desideri.
Ed è qui che ci rivolgiamo a fread. La funzione fread è usata per uno scopo leggermente diverso da fgets: è concepita per leggere da binari (cioè file che non sono originariamente testo leggibile dall'uomo). Poiché il concetto di "stringhe" non è rilevante per i file binari (le strutture dati logiche di solito non sono suddivise in righe), è necessario specificare il numero di byte da leggere.
$ fh = fopen ("miofile", "rb"); $ data = fread ($ file_handle, 4096);L'esempio precedente legge 4096 byte (4 KB) di dati. Nota che indipendentemente dal valore specificato, fread non leggerà più di 8192 byte (8 KB).
Supponendo che il file non superi gli 8 KB, il frammento di codice seguente dovrebbe leggere l'intero file su una riga.
$ fh = fopen ("miofile", "rb"); $ data = fread ($ fh, dimensione del file ("miofile")); fchiudi ($ fh);Se il file è più grande, dovrai usare un ciclo per leggere il resto del file.
Funzione Fscanf
Tornando all'elaborazione della riga, si noti che fscanf è anche il successore della tradizionale funzione di libreria C basata su file. Se non si ha familiarità con essa, fscanf legge i campi di dati in variabili da un file.
lista ($ campo1, $ campo2, $ campo3) = fscanf ($ fh, "% s% s% s");Le stringhe di formattazione utilizzate in questa funzione sono documentate in molte fonti come PHP.net, quindi non ripeterò queste informazioni qui. Basti dire che la formattazione delle stringhe è molto flessibile. Va anche detto che tutti i campi sono inseriti in una variabile restituita dalla funzione. (In C, sarebbero passati come argomenti.)
Funzione Fgetss
La funzione fgetss è diversa dalle tradizionali funzioni di file e ti dà un'idea migliore di cosa può fare PHP. Funziona come fgets, ma elimina tutti i tag HTML o PHP che incontra, lasciando solo il testo "nudo". Prendiamo il file HTML sottostante.
Listato 2. File HTML di esempio
Se capisci cosa significa "Perché non c'è nessuno per non darti dolore" significa che ascolti troppo della band America
Eseguiamolo attraverso la funzione fgetss.
Listato 3. Utilizzo di fgetss
$ file_handle = fopen ("miofile", "r"); while (! feof ($ file_handle)) (echo = fgetss ($ file_handle);) fclose ($ file_handle);Ecco cosa ottieni come output:
Il mio titolo Se capisci cosa "Perché non c'è nessuno per non darti dolore" significa che ascolti troppo della band AmericaFunzione Fpassthru
Indipendentemente da come si leggono i dati dal file, è possibile stampare i dati rimanenti utilizzando la pipe di output standard utilizzando la funzione fpassthru.
fpassthru ($ fh);Questa funzione stampa i dati, quindi non è necessario inserirli in una variabile.
Elaborazione di file non lineare: spostarsi nel file
Naturalmente, le funzioni di cui sopra consentono solo di leggere da un file in sequenza. File più complessi potrebbero richiedere lo spostamento in parti diverse del file all'inizio o alla fine. Per fare ciò, è necessaria la funzione fseek.
fseek ($ fh, 0);L'esempio precedente torna all'inizio del file. Se non vuoi spostarti all'inizio del file, ad esempio un kilobyte è sufficiente, scrivi semplicemente:
fseek ($ fh, 1024);A partire da PHP V4.0, sono disponibili anche diverse altre opzioni. Ad esempio, se hai bisogno di saltare in avanti di 100 byte dalla tua posizione attuale, puoi usare il seguente codice:
fseek ($ fh, 100, SEEK_CUR);Allo stesso modo, il salto indietro di 100 byte viene eseguito da:
fseek ($ fh, -100, SEEK_CUR);Se vuoi tornare a 100 byte prima della fine del file, usa invece SEEK_END.
fseek ($ fh, -100, SEEK_END);Una volta raggiunta la nuova posizione, puoi utilizzare fgets, fscanf o un'altra funzione per leggere i dati.
Nota: non puoi usare fseek su descrittori di file che fanno riferimento a URL.
Catturare un intero file
Passiamo ora a esaminare alcune delle capacità uniche di gestione dei file di PHP: gestire grandi blocchi di dati in una o due righe. Ad esempio, come puoi prendere un file e visualizzare tutti i suoi contenuti sulla tua pagina Web? Bene, hai visto un esempio di utilizzo di un ciclo con fgets. Ma come puoi renderlo più facile? Il processo è quasi ridicolmente semplice con fgetcontents, che mette l'intero file su una stringa.
$ mio_file = file_get_contents ("mionomefile"); echo $ mio_file;Sebbene non sia l'opzione migliore, puoi scrivere questo comando ancora più breve:
echo file_get_contents ("nomefile");Questo articolo riguarda principalmente la gestione dei file locali, tuttavia, vale la pena notare che è anche possibile acquisire, visualizzare e analizzare altre pagine Web utilizzando le funzioni descritte.
echo file_get_contents ("http://127.0.0.1/");Questo comando è in realtà lo stesso di:
$ fh = fopen ("http://127.0.0.1/", "r"); fpassthru ($ fh);Devi guardare questi esempi e pensare: "Questo richiede ancora troppo tempo". Gli sviluppatori PHP sono d'accordo con te. Pertanto, puoi abbreviare il comando precedente in:
file di lettura ("http://127.0.0.1/");La funzione readfile scrive l'intero contenuto di un file o di una pagina Web nel buffer di output per impostazione predefinita. Per impostazione predefinita, questo comando visualizza un messaggio di errore in caso di errore. Per evitare questo comportamento (se lo desideri), prova il comando:
@readfile ("http://127.0.0.1/");Naturalmente, se è necessario elaborare il contenuto dei file, l'unica riga restituita da file_get_contents è probabilmente eccessiva. Potresti voler prima dividerlo in parti usando la funzione split().
$ array = split ("\ n", file_get_contents ("myfile"));Ma perché hai bisogno di tutte queste complicazioni se c'è una funzione perfettamente adatta che farà il lavoro per te? La funzione PHP file() esegue questa operazione in un solo passaggio: restituisce un array di stringhe i cui elementi sono le stringhe del file.
$ array = file ("miofile");Va notato che c'è una leggera differenza tra i due esempi sopra. Il comando split rimuove le nuove righe, mentre il comando file termina con le nuove righe (proprio come con fgets).
Le capacità di PHP, tuttavia, superano di gran lunga quelle descritte sopra. Puoi analizzare interi file .ini in stile PHP con un solo comando parse_ini_file. Il comando parse_ini_file si applica a file simili a quelli del Listato 4.
Listato 4. Un esempio di file .ini
; Nome del commento = Missione "King Arthur" = Cercare il Santo Graal Colore preferito = Blu Samuel Clemens = Mark Twain Caryn Johnson = Whoopi GoldbergI seguenti comandi rappresentano un file come un array e quindi stampano quell'array:
$ file_array = parse_ini_file ("holy_grail.ini"); print_r $ file_array;Questo produrrà il seguente output:
Listato 5. Output
Array (=> King Arthur => Alla ricerca del Santo Graal => Blu => Mark Twain => Whoopi Goldberg)Ovviamente puoi vedere che questo comando ha sezioni unite. Questa è l'impostazione predefinita, ma puoi facilmente apportare le modifiche necessarie utilizzando il secondo argomento per parse_ini_file: process_sections, che è una variabile booleana. Imposta process_sections su True.
$ file_array = parse_ini_file ("holy_grail.ini", vero); print_r $ file_array;E il tuo output sarà simile a:
Listato 6. Output
Array (=> Array (=> King Arthur => Alla ricerca del Santo Graal => Blu) => Array (=> Mark Twain => Whoopi Goldberg))PHP inserisce i dati in un array multidimensionale che può essere facilmente analizzato per l'analisi.
Ma questa è solo la punta dell'iceberg quando si tratta di gestione dei file in PHP. Funzioni più complesse come tidy_parse_file e xml_parse possono aiutarti ad analizzare documenti HTML e XML, rispettivamente. Vedere la sezione per ulteriori informazioni su come funzionano queste funzioni. Vale la pena considerare entrambi se lavori con questi tipi di file, ma invece di esaminare tutti i tipi di file possibili, puoi leggere attentamente il contenuto di questo articolo, dove ci sono alcune buone regole generali per lavorare con le funzioni che ho descritto finora.
Buon stile di programmazione
Non dare mai per scontato che tutto nel tuo programma funzionerà come previsto. Ad esempio: cosa succede se il file che stai cercando è stato spostato? Cosa succede se, a seguito di una modifica dei permessi, non è possibile leggere il contenuto del file? È possibile verificare in anticipo l'esistenza di un file e le autorizzazioni per leggerlo utilizzando i metodi file_exists e is_readable.
Listato 7. Utilizzo di file_exists ed is_readable
$ nomefile = "miofile"; if (file_esiste ($ nomefile) && è_leggibile ($ nomefile)) ($ fh = fopen ($ nomefile, "r"); # Elaborazione fclose ($ fh);)Tuttavia, in pratica, questo pezzo di codice sarà, forse, eccessivo per il tuo compito. La gestione dei valori restituiti da fopen è più semplice e più accurata.
if ($ fh = fopen ($ nomefile, "r")) (# Elaborazione fclose ($ fh);)Poiché fopen restituisce False in caso di errore, ciò garantisce che il file venga elaborato solo se il file può essere aperto. Ovviamente, se il file non esiste o è illeggibile, ti aspetteresti che il valore restituito sia negativo. Pertanto, un tale controllo è una trappola in cui cadono tutti i potenziali problemi. In alternativa, è possibile utilizzare la terminazione del programma o visualizzare un messaggio di errore se non è possibile aprire il file.
Come fopen, le funzioni file_get_contents, file e readfile restituiscono False se il file non può essere aperto o elaborato. Anche le funzioni fgets, fgetss, fread, fscanf e fclose restituiscono False in caso di errore. Ovviamente, ad eccezione di fclose, probabilmente hai già elaborato i risultati che restituiscono. Per quanto riguarda fclose, c'è poco da fare se il descrittore di file non si chiude correttamente, quindi controllare il valore di ritorno di fclose è solitamente eccessivo.
La scelta è tua
PHP non ha carenza di modi efficienti per leggere e analizzare i file. Funzioni classiche come fread possono servirti in modo affidabile la maggior parte del tempo, oppure potresti essere più attratto dalla semplicità del readfile se necessario per completare l'attività. La scelta dipende davvero da ciò che stai cercando di realizzare.
Se si elaborano grandi quantità di dati, è probabile che fscanf sia più utile ed efficiente rispetto, ad esempio, all'utilizzo di file in combinazione con i successivi comandi split e sprintf. In alternativa, se stai semplicemente visualizzando un testo di grandi dimensioni con modifiche minori, le funzioni file, file_get_contents o readfile potrebbero essere più appropriate. È probabile che questa soluzione sia corretta quando si utilizza PHP per la memorizzazione nella cache o anche per la creazione di un proxy temporaneo.
PHP fornisce molti strumenti per lavorare con i file. Conosci meglio ognuno di loro e scopri quali sono gli strumenti migliori per il progetto su cui stai lavorando. Ti viene offerta un'ampia varietà di strumenti software, utilizzali in modo più efficace e divertiti a elaborare i tuoi file con PHP.
JavaScript è bloccato nel tuo browser. Si prega di abilitare JavaScript affinché il sito funzioni!
Lavorare con i file
Lavorare con i file è un importante strumento PHP.
Compresi file esterni
Ogni documento PHP può includere un file utilizzando le istruzioni includere ()... Il suo argomento è il percorso del file. Questa istruzione è comoda da usare quando ci sono pezzi di codice identici in molti programmi PHP. Il contenuto del file di inclusione viene trattato come testo HTML semplice. Affinché il contenuto di questo file venga elaborato come un programma PHP, è necessario inquadrarlo con l'apertura e la chiusura di tag PHP.
Esempio 1
Eco "
... Saluto generale ...
"RISULTATO DELL'ESEMPIO 1:
... Saluto generale ...
...Parte principale...
In questo caso, il risultato è lo stesso se il file top.php incluso contiene solo una riga di testo HTML:
... Saluto generale ...
I file di inclusione possono restituire valori come funzioni. L'uso dell'istruzione return interrompe l'esecuzione di questo file allo stesso modo delle funzioni.
Esempio 2
Includi il file top.php con il programma PHP:
RISULTATO DELL'ESEMPIO 2:
Includi file restituito 56
Istruzioni includere () può essere utilizzato all'interno di un ciclo. In un ciclo includere () viene eseguito ad ogni iterazione. Questo può essere usato per includere più file. Ad esempio:
Per ($ i = 1; $ i<=5; $i++) include("incfile{$i}.htm");
La definizione del nome del file include e il suo caricamento vengono ripetuti ad ogni chiamata includere ()... Ciò significa che se il contenuto del file incluso è cambiato rispetto alla chiamata precedente, verrà caricato il nuovo contenuto.
Operatore includere () può anche essere incluso nel corpo di una dichiarazione condizionale.
Nonostante la somiglianza nell'aspetto con la funzione, includere () una funzione non lo è, ma un costrutto di linguaggio speciale.
Per indicare che il file deve essere incluso solo una volta, usa l'operatore include_once()
Analisi file
PHP contiene molte funzioni che forniscono informazioni sui file. I più comunemente usati sono:
- il file esiste ()- determina l'esistenza del file. Ad esempio: if (! File_exists ("aaa.php")) echo "Attenzione! File aaa.php non trovato!";
- è_file()- determina se l'oggetto in esame è un file. Ad esempio: if (is_file ("bbb.txt")) echo "Stai tranquillo, bbb.txt è un file";
- is_dir()- determina se l'oggetto in esame è una directory. Ad esempio: if (is_dir ("/ tmp")) echo "Infatti, / tmp è una directory";
- è_leggibile ()- determina se il file è leggibile. Ad esempio: if (is_readable ("db.dbf")) echo "db.dbf può essere letto";
- è_scrivibile ()- determina se il file è disponibile per la scrittura. Ad esempio: if (is_writable ("db.dbf")) echo "Puoi scrivere su db.dbf";
- dimensione del file ()- definisce la dimensione del file in byte.
- filemtime ()- definisce la data e l'ora dell'ultima modifica del file.
- filetime ()- definisce la data e l'ora dell'ultimo accesso al file.
Esempio 3
"; echo" $ f ". (è_leggibile ($ f)?" ":" non ")." leggibile
"; echo" $ f ". (è_scrivibile ($ f)?" ":" non ")." scrivibile
"; echo" dimensione di $ f in byte - ". (dimensione file ($ f))."
"; echo" $ f ultima modifica - ". (date (" d M Y H: i ", filemtime ($ f)))."
"; echo" $ f ultimo accesso - ". (date (" d M Y H: i ", fileatime ($ f)))."
"; } ?>
RISULTATO DELL'ESEMPIO 3:
Top.php - file top.php - non directory top.php leggibile top.php scrivibile dimensione top.php in byte - 732 ultima modifica top.php - 04 ott 2005 20:21 ultimo accesso a top.php - 20 ott 2005 14 :01
Attenzione! Queste funzioni non funzionano con i file eliminati. Possono essere applicati solo al file system locale.
Gestione dei file
PHP contiene molte funzioni di gestione dei file. I più comunemente usati sono:
- tocco ()- crea un file vuoto con il nome dato. Se tale file esiste già, la funzione cambierà la data di modifica. Ad esempio: toccare ("ex1.txt");
- copia ()- copia il file. Per copiare file in php, usa la funzione copy ($ source, $ result). Deve solo passare due parametri: l'origine $ source e il nome del file di copia - $ risultato. Vale la pena notare che è necessario indicare gli indirizzi completi dei file. Un esempio di utilizzo della funzione di copia:
- scollega ()- elimina il file specificato. Ad esempio:
- apri ()- apre un file locale o remoto e vi restituisce un puntatore. Il puntatore viene utilizzato in tutte le operazioni con il contenuto del file. Argomenti: nome del file e modalità di apertura.
R lettura. Il puntatore del file è impostato all'inizio r + leggendo e scrivendo. Il puntatore del file è impostato all'inizio w registrazione. Il puntatore del file è impostato all'inizio del file. Tutti i vecchi contenuti del file vengono persi. Se il file con il nome specificato non esiste, la funzione tenta di crearlo w + leggendo e scrivendo. Il puntatore del file è impostato all'inizio del file. Tutti i vecchi contenuti del file vengono persi. Se il file con il nome specificato non esiste, la funzione tenta di crearlo un registrazione. Il puntatore del file è impostato alla fine del file. Se il file con il nome specificato non esiste, la funzione tenta di crearlo un + leggendo e scrivendo. Il puntatore del file è impostato alla fine del file. Se il file con il nome specificato non esiste, la funzione tenta di crearlo Ad esempio:
$ fp = fopen ("http://www.php.net/", "r"); // per leggere $ fp = fopen ("ex1.txt", "w"); // per scrivere $ fp = fopen ("ex2.txt", "a"); // da aggiungere alla fine
Se il file non può essere aperto, è possibile interrompere l'esecuzione del programma. Ad esempio:
$ fp = fopen ("ex1.txt", "w") or die ("Impossibile aprire il file");
- fchiudi ()- chiude il file. Argomento: il puntatore al file ottenuto in precedenza dalla funzione fopen(). Ad esempio: fclose ($ fp);
- fede ()- controlla la fine del file. Argomento: puntatore al file.
- fgetc()- leggere il carattere successivo dal file. Argomento: puntatore al file.
- fget ()- leggere la riga successiva del file. Argomenti: puntatore al file e lunghezza della riga da leggere. L'operazione si interrompe dopo che è stato letto il numero specificato di caratteri o dopo che viene incontrata la fine di una riga o di un file.
Esempio 4
Leggere righe da un file "; ?> - fread ()- funzione generale di lettura da un file. Argomenti: puntatore al file e numero di caratteri da leggere.
- cerca ()- rientro dall'inizio del file. Argomenti: puntatore al file e offset.
Esempio 5
Visualizzazione della seconda metà del file - fput ()- scrivere una riga su un file. Gli argomenti sono puntatore al file e stringa.
- fscrivi ()- analogo completo della funzione fput ().
Esempio 6
Scrivere e aggiungere al file - gregge ()- blocca il file, ad es. impedisce ad altri utenti di leggere o scrivere su questo file finché la persona che ha posizionato il blocco non termina di lavorare sul file. Argomenti: puntatore al file e numero della modalità di blocco.
Esempio 7
Blocco file Chiusura con gregge () non è assoluto. Saranno presi in considerazione solo quei programmi che utilizzano anche questa funzione.
PHP version> = 4.3.0 ha nuove comode funzioni per lavorare con i file:
- file_get_contents ()- leggi l'intero file o url
- file_put_contents ()- scrivere file
Lavorare con le directory
PHP ha diverse funzioni per lavorare con le directory:
- mkdir()- creazione di una directory. Argomenti: percorso della directory e modalità di accesso. La modalità di accesso è un numero ottale di tre cifre con uno zero iniziale. La prima cifra è il diritto di accesso per il proprietario, la seconda per il gruppo e la terza per tutti gli altri. La modalità di accesso viene ignorata su Windows. Il sistema UNIX definisce i seguenti diritti di accesso:
Ad esempio, Accesso completo per il proprietario, Leggi ed esegui per un gruppo ed Esegui per tutti gli altri:
Mkdir ("testdir", 0751);
- rmdir()- eliminazione di una directory. Argomento: percorso della directory. Puoi eliminare una directory vuota solo se ne hai il diritto. La funzione restituisce true in caso di successo.
- apri ()- aprire una directory. Argomento: percorso della directory. Se si verifica un errore, la funzione restituisce false. L'errore all'apertura può essere causato dal fatto che la directory non esiste o il programma non ha il diritto di leggerla.
- readdir ()- leggere la directory. Argomento: percorso della directory. Restituisce una stringa contenente il nome del file o della sottodirectory trovati. Quando viene raggiunta la fine della directory, la funzione restituisce false.
Esempio 8
Lettura di una directory "; ?>L'espressione di test del ciclo non funzionerà come vorrebbe se nella directory è presente un file denominato "0". In questo caso, il nome "0" verrà convertito in 0, causando la fine del ciclo. Puoi evitarlo adottando ulteriori misure di sicurezza modificando l'espressione di test:
Gettype ($ f = readdir ($ dh))! = "Booleano"
Oltre a usare la funzione fgetc() fgets() fgetss(), puoi usare
$ file = file ($ nome file). Legge $ filename in un array ($ file).Esempio:
$ file = file ($ nome file); per ($ i = 0; $ i<=count($file); $i++) { echo $file[$i], "
"; }
Trasferimento file dal server. Download file. Scarica.
Download manuale, o come script per aprire una finestra per il salvataggio del file per l'utente. Affinché il browser possa aprire la finestra di dialogo "Salva file" con il nome file file.dat, lo script deve inviare le seguenti intestazioni:
Intestazione ("Contenuto-Disposizione: allegato; nome file = file.dat"); header ("Content-Type: application / x-force-download; name = \" file.dat \ "");
Un esempio finito di invio di un file dal disco:
Non sarebbe male fare riferimento allo script anche come http: //.../download.php?File.dat, altrimenti i browser basati su Mozilla potrebbero provare a scrivere il file come file.dat.php. o specifica l'attributo di download: Download Nota: Non utilizzare l'intestazione ("Cache-Control: no-cache") in tali script, la maggior parte delle versioni di Internet Explorer non sarà in grado di scaricare il file.
Il seguente esempio di script dimostra come organizzare la ripresa del supporto:
Si presume che $ cd sia il percorso del file, $ fn è il nome del fileCome faccio a trasferire un file sul server?
Funzioni per lavorare con le directory
- chdir() - Cambia directory chdir booleano (stringa str)
- chroot() - Cambia la directory principale chroot booleano (stringa str)
- closedir() - Libera un handle di directory void closedir (catalogo risorse)
Modifica la directory PHP corrente nel parametro str specificato. Restituisce TRUE in caso di successo, FALSE in caso di errore
Modifica la directory principale del processo corrente nel parametro str passato. Restituisce TRUE in caso di successo, FALSE in caso di errore.
Nota: questa funzione non è implementata per le piattaforme Windows.
Chiude il flusso associato al catalogo e passato come parametro del catalogo. Prima di utilizzare questa funzione, lo stream deve essere aperto utilizzando la funzione opendir().
dir - La classe della directory
Un meccanismo pseudo-object-oriented per leggere la directory passata nel parametro directory. Dal momento in cui la directory viene aperta, diventano disponibili due proprietà della classe. La proprietà "handle" può essere utilizzata con altre funzioni di directory come readdir(), rewinddir() e closedir(). La proprietà "percorso" contiene il percorso della directory aperta. Sono disponibili tre metodi: lettura, riavvolgimento e chiusura.
Si noti il modo in cui viene verificato il valore restituito dai metodi della classe dir() nell'esempio seguente. Questo esempio controlla un valore per l'identità (le espressioni sono identiche quando sono uguali e dello stesso tipo - vedere il capitolo Operatori di confronto per maggiori informazioni) su FALSE, perché altrimenti, qualsiasi voce di directory il cui nome può essere espresso come FALSE, interromperà il ciclo.
Codice d'esempio:
maneggiare. "
\ n "; echo" Percorso: ". $ d-> percorso."
\ n "; while (false! == ($ entry = $ d-> read ())) (echo $ entry."
\ n ";) $ d-> chiudi ();?>
Nota: l'ordine in cui il metodo "read" restituisce le voci della directory dipende dal sistema operativo.
Nota: Inoltre, PHP definisce automaticamente una classe Directory interna, il che significa che non è possibile definire le proprie classi con lo stesso nome.
Restituisce il nome della directory di lavoro corrente.
Restituisce un handle a una directory per un uso successivo con le funzioni closedir(), readdir() e rewinddir().
Se il percorso non esiste o la directory nel percorso specificato non può essere aperta a causa di restrizioni legali o errori del file system, opendir() restituisce FALSE e genera un messaggio di errore PHP E_WARNING. È possibile impedire la visualizzazione del messaggio di errore facendo precedere il nome della funzione opendir() da "@".
Codice d'esempio
Dal PHP 4.3.0, il parametro del percorso può anche essere qualsiasi URL a cui si accede per ottenere un elenco dei suoi file e directory.Tuttavia, questo metodo funziona solo quando si utilizza il file: // url wrapper.In PHP 5.0 .0 supporto per ftp: // è stato aggiunto il wrapper dell'URL.
Restituisce il nome dell'elemento successivo nel catalogo. I nomi degli elementi vengono restituiti in un ordine dipendente dal filesystem.
Notare come l'esempio seguente controlla il valore restituito di readdir(). Questo esempio controlla un valore per l'identità (le espressioni sono identiche quando sono uguali e sono valori dello stesso tipo - vedere il capitolo Operatori di confronto per maggiori informazioni) su FALSE, perché in caso contrario, qualsiasi voce di directory il cui nome può essere espresso come FALSE , interromperà il ciclo (ad esempio, un elemento denominato "0").
Codice d'esempio
Nota che la funzione readdir() restituisce anche elementi con nome e se non vuoi ottenere quei valori, scartali semplicemente:
Codice d'esempio
Svuota il flusso del catalogo passato nel parametro catalog in modo che punti all'inizio del catalogo
Restituisce un array contenente i nomi dei file e delle directory situati lungo il percorso passato nel parametro catalog. Se la directory non lo è, la funzione restituisce il valore booleano FALSE e genera un messaggio di errore a livello E_WARNING.
Per impostazione predefinita, l'ordinamento viene eseguito in ordine alfabetico crescente. Se viene specificato il parametro dell'ordine facoltativo (uguale a 1), l'ordinamento viene eseguito in ordine alfabetico decrescente. Codice d'esempio
Il risultato sarà qualcosa del tipo:
Array (=>. => .. => bar.php => foo.txt => somedir) Array (=> somedir => foo.txt => bar.php => .. =>.)
Codice d'esempio
ESEMPIO DI RISULTATO:
Array (=>. => .. => bar.php => foo.txt => somedir) Array (=> somedir => foo.txt => bar.php => .. =>.)
In PHP spesso devi occuparti della creazione di un file... tutto è molto semplice non c'è nessun file sul disco, il codice è stato eseguito e il file è apparso, quindi puoi leggere questo file in un'altra variabile o anche in qualsiasi pagina su Internet e poi scrivi qualcosa lì ... ma per questo devi conoscere funzioni speciali ... di più su questo in questo articolo ...
Per creare un file php nello script eseguibile, devi solo specificare alcune funzioni:
Consideriamo subito un esempio:
$ text = "Qui un po' di testo da scrivere nel file";
$ fp = fopen ("file.txt", "w");
fwrite ($ fp, $ testo);
fchiudi ($ fp);
?>
Qui dovresti saperlo:
apri ()- la funzione apre il file in lettura o in scrittura e perfezionamenti;
Questi perfezionamenti (il parametro mode della funzione fopen) sono molto importanti:
- "R"- apri file in php Solo per leggere... Il cursore è posizionato all'inizio.
- "r +"- apri file in php per leggere e per scrivere... Il cursore è posizionato all'inizio. !!! - con queste due modalità r e r +, i file devono essere già creati (altrimenti verrà fuori un errore Avvertimento: fopen (file.txt): impossibile aprire il flusso: nessun file o directory di questo tipo in ...), e leggiamo solo o abbiamo l'opportunità di aggiungere.
- "w"- il file viene aperto SOLO per la scrittura. Il file viene troncato a lunghezza zero, ovvero viene sovrascritto. Viene scritto ciò che è necessario e il cursore viene posizionato all'inizio.
- "w +"- il file viene aperto per la scrittura E LA LETTURA! Il resto è lo stesso della modalità" w ". !!! - con queste due modalità - se il file non è stato creato - PROVA A CREARLO!
- "un"- apri il file SOLO per la scrittura. A differenza di" w ", questo parametro non sovrascrive il contenuto del file, ma posiziona il cursore alla fine della riga e aggiunge alla fine il contenuto che volevamo aggiungere.
- "un +"- apri un file per scrivere e leggere.
fscrivi($ fp, $ text) - la funzione di scrivere su un file in php - cioè, ciò che è nella variabile $ text viene scritto nel file, che è nella variabile $ fp;
fchiudi($ fp) - la funzione di chiudere il file che abbiamo scritto nella variabile $ fp;
Tutto ora puoi tranquillamente creare correttamente i file in php, aprirli per la lettura e la modifica.
Utili componenti aggiuntivi e funzioni PHP per lavorare con un file aperto:
mentre (! feof ($ fp)) (
$ miotesto = fgets ($ fp, 99);
echo $ miotesto."
";
}
qui la condizione è soddisfatta - "fino alla fine del file, quindi fallo" mentre (! feof ($ fp))
1. Funzione fget($ fp, 99) - consente di dividere tutto il contenuto in sezioni di 99 byte e oltre, per vederlo più chiaramente mettiamo un tag
Questa funzione stringa fget(risorsa handle [, int length]) per impostazione predefinita accetta una lunghezza di 1024 byte (1 kilobyte), se non specificato lo farà. Questo parametro è facoltativo dal PHP 4.2.0 (restituisce FALSE in caso di errore)
Funzioni aggiuntive per aprire, scrivere e creare un file
Funzione - int readfile(string nomefile [, bool use_include_path [, contesto risorsa]]) - legge il file nel suo insieme.
Legge un file e scrive il contenuto nel buffer di output. E restituisce il numero di byte stampati. In caso di errore, tornerà, se il cane non viene utilizzato - @readfile.
Qualcosa del genere risulterà:
Alla fine di una parola, il tag è
.
B. Funzione - array file(string filename [, int use_include_path [, resource context]]) fa lo stesso della funzione readfile, con un'eccezione, aggiunge il contenuto del file all'array:
Pertanto, puoi leggere qualsiasi pagina su Internet: $ righe = file ("http: // site /"); e scorrere l'array attraverso la funzione foreach;
3a. Funzione stringa file_get_contents(string nomefile [, bool use_include_path [, resource context [, int offset [, int maxlen]]]]) - consente di ottenere il contenuto come una singola riga.
Questa è una funzione PHP più versatile per leggere un file, simile alla funzione file, solo il contenuto viene restituito a una stringa, non a un array, e le condizioni possono essere impostate - con quale byte iniziare - compensare e con quale finire - maxlen... Restituisce FALSE in caso di errore.
Importante!!!- in questo caso la funzione sostituisce 3 contemporaneamente: fopen(), fread() e fclose() e quindi elimina i timbri.
3b. Funzione interna file_put_contents(string nome file, dati misti [, flag int [, contesto risorsa]]) - identico alla chiamata sequenziale delle funzioni fopen(), fwrite() e fclose() - restituisce il numero di byte scritti.
