$Vdata = file_get_contents("file di testo.txt");

Ma ora ho bisogno di caricare un file PHP.

Immagino cosa vuoi ottenere Contenuto generato da PHP, se è così:

$Vdata = file_get_contents("http://IL TUO_HOST/IL TUO/FILE.php");

Altrimenti, se vuoi Codice sorgente del file PHP, questo è lo stesso del file .txt:

$Vdata = file_get_contents("percorso/del/TUO/FILE.php");

ob_start(); includi "tuofile.php"; $myvar = ob_get_clean();

Se stai usando http://, come suggerito da eyel, sarai in grado di leggere solo l'output dello script PHP. Puoi leggere uno script PHP solo se si trova sullo stesso server del tuo script. Quindi puoi usare qualcosa di simile

$Vdata = file_get_contents("/percorso/del/tuo/file.php");

Se desideri scaricare un file senza eseguirlo tramite un server Web, dovrebbe funzionare quanto segue.

$stringa = eval(file_get_contents("file.php"));

Quindi verrà caricato il contenuto del file. Il file PHP deve essere completamente formato con i tagPer eval per valutarlo.

In teoria potresti semplicemente usare fopen e poi usare stream_get_contents.

$stream = fopen("file.php","r"); $stringa = stream_get_contents($stream); fclose($flusso);

In alternativa, puoi avviare il buffering dell'output, eseguire un include / require e quindi interrompere il buffering. Con ob_get_contents() puoi semplicemente ottenere cose che sono state emesse da un altro file PHP in una variabile.

file_get_contents() non funzionerà se il tuo server lo è disabilitato allow_url_fopen. La maggior parte degli host web condivisi sono disabilitati per impostazione predefinita a causa di rischi per la sicurezza. Inoltre, nel PHP6 opzione allow_url_fopen non esisterà più e tutte le funzionalità agiranno come se fossero disabilitate in modo permanente. Quindi questo è un pessimo metodo da usare.

Il tuo miglior caso d'uso se stai accedendo al file tramite http è cURL

Prima di provare a lavorare con un file, è una buona idea assicurarsi che esista. Di solito vengono utilizzate due funzioni per risolvere questo problema:

file_exists() e is_file().

La funzione file_exists() controlla se il file specificato esiste. Se il file esiste, la funzione restituisce TRUE, altrimenti restituisce 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($filename)) :

print "File $nomefile non esiste!";

è_file()

La funzione is_file() verifica l'esistenza di un determinato file e la capacità di eseguire operazioni di lettura/scrittura su di esso. Fondamentalmente, 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 che le operazioni possano essere eseguite su di esso:

$file = "qualchefile.txt";

se (è_file($file)) :

print "Il file $file è valido ed esiste!";

print "Il file $file non esiste o non è un file valido!";

Dopo esserti assicurato che il file desiderato esista e che puoi eseguire varie operazioni di lettura/scrittura con esso, puoi procedere al passaggio successivo: aprire il file.

La funzione filesize() restituisce la dimensione (in byte) del file con il nome dato, o FALSE in caso di errore. La sintassi della funzione filesize() è:

int filesize(stringa nomefile)

Supponiamo che tu voglia determinare la dimensione del file pasticceria.txt. Puoi usare la funzione filesize() per ottenere le informazioni di cui hai bisogno:

$fs = dimensionefile("pasticceria.txt"); print "Pastry.txt è $ fs byte.";

Viene visualizzato il seguente risultato:

Pastry.txt è di 179 byte.

Prima di eseguire operazioni su un file, devi aprirlo e associarlo a un handle di file e, quando hai finito di lavorare con il file, devi chiuderlo. Questi argomenti sono trattati 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 il file (se esiste) e restituisce un intero -- il cosiddetto handle di file(manico d'archivio). La sintassi della funzione fopen() è:

int fopen(file stringa, modalità stringa[, int include_path])

Il file aperto può risiedere nel file system locale, esistere come input/output standard o rappresentare un file su un sistema remoto accettato da HTTP o FTP.

Il parametro file può assumere diverse forme, come elencato di seguito:

Se il parametro contiene il nome di un file locale, la funzione fopen() apre quel file e restituisce un handle.

Se il parametro è impostato su 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 la modalità FTP passiva, la chiamata fopen() fallirà. Inoltre, i file FTP vengono aperti sia per la lettura che per la scrittura.

Quando opera in modalità passiva, il server LR attende le connessioni dai client. Quando si lavora in modalità attiva, il server stesso stabilisce una connessione con il client. L'impostazione predefinita è solitamente la modalità attiva.

Il parametro mode determina se il file può essere letto o scritto. In tavola. 7.1 elenca alcuni valori che determinano la modalità di apertura del 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	Registra 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 tenta di 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 tenta di crearlo.
un	Registra solo. Il puntatore della posizione corrente è impostato alla fine del file. Se il file non esiste, la funzione tenta di crearlo.
a+	Leggendo e scrivendo. Il puntatore della posizione corrente è impostato alla fine del file. Se il file non esiste, la funzione tenta di crearlo.

Se il terzo parametro opzionale include_path è 1, il percorso del file è relativo alla directory include specificata nel file php.ini (vedi Capitolo 1).

Quello che segue è un esempio di apertura di un file con la funzione fopen(). La chiamata die(), usata insieme a fopen(), stampa un messaggio di errore se il file non si apre:

$file = "datautente.txt"; // Qualche file

$fh = fopen($file, "a+") o die("File ($file) non esiste!");

Il frammento di codice seguente apre una connessione a un sito PHP (http://www.php.net):

$site = "http://www.php.net": // Server accessibile tramite HTTP

$sh = fopen($sito., "r"); //Associa il manipolatore con la pagina dell'indice di Php.net

Il file dovrebbe sempre essere chiuso con la funzione fclose() dopo il completamento.

La funzione fclose() chiude un file con l'handle specificato. Restituisce VERO in caso di successo, FALSO in caso di errore. La sintassi della funzione fclose() è:

int fclose(int manipolatore)

La funzione fclose() chiude con successo solo quei file che erano stati precedentemente aperti dalle funzioni fopen() o fsockopen(). Un esempio di chiusura di un file:

$file = "datautente.txt";

if (file_exists($file)) :

$fh = fopen($file, "r");

// Esegue operazioni sui file

print "File Sfile non esiste!";

Scrivi su file

Sui file aperti vengono eseguite due operazioni di base: lettura e scrittura.

La funzione is_writeable() verifica che il file esista e sia scrivibile. La scrivibilità è verificata sia per il file che per la directory. La sintassi della funzione is_writeable() è:

bool is_writeable(file stringa)

Una considerazione importante: molto probabilmente PHP verrà eseguito con l'ID utente utilizzato dal server Web (di solito "nessuno"). Un esempio di utilizzo di is_writeable() è fornito nella descrizione della funzione fwrite().

La funzione fwrite() scrive il contenuto di una variabile stringa nel file specificato dall'handle del file. La sintassi della funzione fwrite() è:

int fwrite(int manipolatore, variabile stringa [, lunghezza int])

Se viene passato un parametro di lunghezza facoltativo durante la chiamata della funzione, la registrazione si interrompe dopo che è stato scritto il numero di caratteri specificato o quando viene raggiunta la fine della stringa. La verifica della capacità di scrivere su un file è illustrata nell'esempio seguente:

// Informazioni sul traffico sul sito dell'utente

$dati = "08:13:00|12:37:12|208.247.106.187|Win98";

$nomefile = "qualchefile.txt";

// Se il file esiste e può essere scritto

if (è_riscrivibile($nomefile)) :

$fh = fopen($nomefile, "a+");

// Scrive il contenuto di $data in un file

$successo - fwrite($fh, $dati);

// chiudi il file

fclose($fh); altro:

print "Impossibile aprire Sfilename per la scrittura";

La funzione fputs() è un alias per fwrite() e può essere usata ovunque venga usata fwrite().

La funzione fputs() è un alias per fwrite() e ha esattamente la stessa sintassi. La sintassi della funzione fputs() è:

int fputs(int manipolatore, variabile stringa [, lunghezza int])

Personalmente, preferisco usare fputs(). Tieni presente che questa è solo una questione di stile e non ha nulla a che fare con le differenze tra le due funzioni.

Lettura da un file

Indubbiamente, la lettura è l'operazione più importante eseguita sui file. Di seguito sono descritte alcune delle caratteristiche che migliorano l'efficienza della lettura di un file. La sintassi di queste funzioni copia quasi esattamente la sintassi di funzioni di registrazione simili.

La funzione i s_readable() consente di assicurarsi che il file esista e che sia consentita un'operazione di lettura. La leggibilità è verificata sia per il file che per la directory. La sintassi della funzione is_readable() è:

boh! is_readable(file stringa]

Molto probabilmente, PHP verrà eseguito con l'ID utente utilizzato dal server web (di solito "nessuno"), quindi affinché la funzione is_readable() restituisca TRUE, tutti devono poter leggere il file. L'esempio seguente mostra come verificare 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 "$nomefile non è leggibile!";

La funzione fread() legge il numero specificato di byte dal file specificato dall'handle di file. La sintassi della 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 dopo aver letto il numero di byte specificato o quando viene raggiunta la fine del file. Si consideri il file di testo pastry.txt mostrato nel Listato 7.1. La lettura e l'output di questo file nel browser viene eseguita dal seguente frammento:

$fh = fopen("pasticceria.txt", "r") o die("Impossibile aprire il file!");

$file = fread($fh, dimensione file($fh));

Usando la funzione fllesize() per determinare la dimensione di pasticceria.txt in byte, ci si assicura che la funzione fread() legga l'intero contenuto del file.

Listato 7.1. File di testo pasticceria.txt

Ricetta: Pasta frolla

1 1/4 tazze 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 d'acqua

La funzione fgetc() restituisce una stringa contenente un carattere dal file nella posizione corrente del puntatore o FALSE se viene raggiunta la fine del file. La sintassi della funzione fgetc() è:

stringa fgetc (manipolatore int)

Il manipolatore deve fare riferimento a un file leggibile aperto (vedere la descrizione della 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; nel frattempo;

La funzione fgets() restituisce la stringa letta dalla posizione corrente del puntatore nel file specificato dal filehandle. Il puntatore al file deve puntare a un file leggibile aperto (vedere la descrizione della funzione is_readable() in precedenza in questo capitolo). Sintassi della funzione fgets():

string fgets (manipolatore int, lunghezza int)

La lettura si interrompe quando si verifica una delle seguenti condizioni:

• leggi dalla lunghezza del file -- 1 byte;
• è stato letto un carattere di nuova riga dal file (incluso nella stringa restituita);
• end-of-file (EOF) è stato letto dal file.

Se vuoi leggere il file riga per riga, passa nel secondo parametro un valore che è ovviamente maggiore del numero di byte nella riga. Un esempio di lettura e output di un file riga per riga:

$fh = fopen("pasticceria.txt", "r");

mentre (!feof($fh));

$riga = fgets($fh, 4096);

stampa $ riga. "
";

La funzione fgetss() è esattamente la stessa di fgets() con un'eccezione: tenta di rimuovere tutti i tag HTML e PHP dal testo letto:

string fgetss(Int manipolatore, int lunghezza [, stringa consentiti_tags])

Prima di passare agli esempi, dai un'occhiata al Listato 7.2 -- questo file è usato nei Listati 7.3 e 7.4.

Listato 7.2. file science.html

Scoperta forma di vita aliena

20 agosto 2000

Questa mattina presto, una strana nuova forma di fungo è stata trovata in crescita nell'armadio del vecchio frigorifero dell'appartamento di W. J. Gilmore.Non è noto se la potente radiazione emanata dal monitor del computer dell'inquilino abbia aiutato in questa evoluzione.

Listato 7.3. Rimozione dei tag dal file HTML prima della visualizzazione nel browser

$fh = fopen("scienza.html", "r");

mentre (!feof($fh)) :

stampa 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, ad eccezione di alcuni, ad esempio i tag di interruzione di riga
. Il Listato 7.4 mostra come farlo.

Listato 7.4. Rimozione selettiva di tag da un file HTML

$fh = fopenC"scienza.html", "r");

$consentito="
";

mentre (!feof($fh)) :

print fgetss($fh. 2048, $consentito);

Risultato:

Ultime notizie - Scienza Scoperta una forma di vita aliena il 20 agosto 2000 Questa mattina presto, una strana nuova forma di fungo è stata trovata che cresceva nell'armadio del vecchio frigorifero dell'appartamento di WJ Gilmore.Non è noto se la potente radiazione emanata dal monitor del computer dell'inquilino abbia aiutato in questo 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 include_path])

Se il terzo parametro opzionale include_path è 1, il percorso del file è relativo alla directory include specificata nel file php.ini (vedi Capitolo 1). Il Listato 7-5 usa la funzione file() per caricare il file pasticceria.txt (vedi Listato 7-1).

$matrice_file = file("pasticceria.txt");

while (list($numero_riga. $riga) = ciascuno($array_file)):

Stampa" Riga$numero_riga:", htmlcaratteri speciali($riga), "
\n"

Ogni riga dell'array viene emessa 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

Linea 4: 1/4 di cucchiaino di sale

Linea 5: 3 cucchiai d'acqua

Reindirizzamento di un file allo standard output

La funzione readfile() legge il contenuto di un file e lo scrive nell'output standard (nella maggior parte dei casi, nel browser). La sintassi della funzione readfile() è:

int readfile(string file[, int include_path])

La funzione restituisce il numero di byte letti. Il file può risiedere nel file system locale, esistere come input/output standard o rappresentare un file su un sistema remoto accettato da HTTP o FTP. Il parametro file è impostato secondo le stesse regole della funzione fopen().

Supponiamo che tu abbia un file latorre.txt che desideri visualizzare nel browser:

Ristorante "La Torre". situato a Nettuno, in Italia, offre una miscela eclettica di stile. storia, e una buona cucina di mare. All'interno delle mura del borgo medievale che circonda la città, si può cenare osservando i passanti che fanno shopping nelle boutique del paese. Il comfort unito solo al pesce più fresco fanno di La Torre uno dei migliori ristoranti d'Italia.

Quando viene eseguito il seguente snippet, l'intero contenuto di latorre.txt viene inviato al flusso di output standard:

$file_ristorante = "latorre.txt";

// Invia l'intero file allo standard output

readfile($file_ristorante);

Apertura del filehandle di un processo

Insieme ai file normali, puoi aprire i filehandle per interagire con i processi sul server. Il problema è risolto dalla funzione popen(), che ha la seguente sintassi:

int popen(comando stringa, modalità stringa)

Il parametro command specifica il comando di sistema da eseguire e il parametro mode descrive la modalità di accesso:

// Apri il file "spices.txt" per la scrittura

$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");

// Chiudi il manipolatore

// Apri un processo UNIX grep per cercare la parola Basil in spices.txt

$fh - popen("grep Basil< spices.txt", "r");

// Stampa l'output di grep

Il risultato si presenta così:

Basilico, salvia, zenzero

La funzione fpassthru() è analoga alla funzione passthru() discussa nella sezione "Esecuzione di programmi esterni" di questo capitolo.

Dopo che tutte le operazioni sono state completate, il file o il processo deve essere chiuso. La funzione pclose() chiude la connessione al processo specificato dall'handle, in modo simile a come la funzione fclose() chiude un file aperto dalla funzione fopen(). sintassi della funzione pclose():

int pclose(int manipolatore)

Nel parametro manipolatore il manipolatore ottenuto in precedenza da una chiamata popen() riuscita viene passato.

Apertura di una connessione presa

PHP non si limita all'interazione con file e processi: puoi anche creare connessioni socket. presa(socket) è un'astrazione software che consente di comunicare con vari servizi su un altro computer.

La funzione fsockopen() stabilisce una connessione socket a un server su Internet

tramite protocollo TCP o UDP. La sintassi della funzione fsockopen() è:

int fsockopen (string node, int port [, int error_code [, string error_text [, int timeout]]])

I parametri facoltativi error_code e error_text 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 per quanto tempo attendere una risposta dal server (in secondi). Il Listato 7-6 mostra come usare la funzione fsockopen() per ottenere informazioni su un server. Prima di esaminare il Listato 7.6, tuttavia, c'è un'altra funzione che deve essere introdotta, socket_set_blocking().

UDP (User Datagram Protocol) è un protocollo di comunicazione non orientato alla connessione.

socket_set_blocking()

La funzione socket_set_b1ocki ng() consente di impostare i controlli di timeout per le operazioni del server:

socket_set_blocking (manipolatore int, modalità booleana)

Il parametro manipolatore specifica il socket aperto in precedenza e il parametro mode seleziona la modalità a cui passa il socket (TRUE per la modalità di blocco, FALSE per la modalità di non 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 la connessione al nodo

$fp - fsockopen($host, 80, &$errno, &$errstr, 30);

// Passa alla modalità di blocco

socket_set_blocking($fp, 1),

// Invia intestazioni

fputs($fp,"GET $percorso HTTP/1.1\r\n");

fputs($fp, "Ospite: $host\r\n\r\n"); $x = 1;

// Ottieni le intestazioni

mentre($x< 10) :

$intestazioni = fgets($fp, 4096);

// Chiudi il manipolatore

getthehost("www.apress.com", "/");

Il Listato 7.6 produce il seguente risultato:

HTTP/1.1 200 OK Server: Microsoft-IIS/4.0 Posizione del 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à interrotta automaticamente al termine dello script in cui è stata richiamata la funzione. Sintassi della funzione pfsockopen():

int pfsockopen (string host, int port [, int error_code [, string error_text [, int timeout]]])

A seconda degli obiettivi specifici 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 soprattutto quando si amministra il sistema tramite un browser Web, nonché per ottenere più comodamente informazioni di riepilogo sul sistema.

La funzione exec() esegue il programma dato e restituisce l'ultima riga del suo output. La sintassi della funzione exec() è:

string exec (comando stringa [, array di stringhe [, ritorno int]])

Si noti che la funzione exec() esegue solo il comando, non emettendo i risultati del suo lavoro. Tutto l'output dei comandi può essere archiviato in un parametro array opzionale. Inoltre, se viene specificata anche una variabile di ritorno quando viene specificato un parametro array, a quest'ultimo viene assegnato il codice di ritorno del comando eseguito.

Il Listato 7.7 mostra come usare la funzione exec() per eseguire la funzione ping di 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 tempo=66.602 ms

64 byte da 208.247.106.187: icmp_seq=1 ttl=243 tempo=55.723 ms

64 byte da 208.247.106.187: icmp_seq=2 ttl=243 tempo=70.779 ms

64 byte da 208.247.106.187: icmp_seq=3 ttl=243 tempo=55.339 ms

64 byte da 208.247.106.187: icmp_seq=4 ttl=243 tempo=69.865 ms

Statistiche 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

C'è un altro modo per eseguire comandi di sistema che non richiede funzioni di chiamata: il comando eseguito è racchiuso in backtick (` `) e i risultati del suo lavoro vengono visualizzati nel browser. Esempio:

Stampa"

$ uscita

";

Questo frammento di codice stampa il contenuto della directory in cui si trova lo script nel browser.

Il parametro interno ping -c 5 (-n 5 su un sistema Windows) specifica il numero di volte in cui eseguire il polling del server.

Se vuoi semplicemente restituire l'output grezzo 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: restituisce automaticamente i risultati del comando. La sintassi della funzione passthru() è:

void passthru(comando stringa [, int return])

Se il parametro di ritorno facoltativo viene passato nella chiamata passthru(), questa variabile viene impostata sul codice di ritorno del comando eseguito.

escapeshellcmd()

La funzione escapeshellcmd() esegue l'escape di tutti i caratteri potenzialmente pericolosi che possono essere inseriti dall'utente (ad esempio, su un modulo HTML) per eseguire i comandi exec(), passthru(), system() o popen(). Sintassi:

stringa escapeshellcmd (comando stringa)

L'input dell'utente dovrebbe sempre essere trattato con un certo grado di cautela, ma anche così, gli utenti possono immettere comandi che verranno eseguiti dalle funzioni di esecuzione dei comandi del sistema. Considera il seguente frammento:

$ input_utente = `rm -rf *`; // Elimina la directory principale e tutte le sue sottodirectory

exec($input_utente); // Esegui $user_input !!!

Se non vengono prese precauzioni, un tale comando porterà al disastro. Tuttavia, puoi utilizzare le funzioni escapeshellcmd() per sfuggire all'input dell'utente:

$ input_utente = `rm - rf *`; // Elimina la directory principale e tutte le sue sottodirectory

exec(escapeshellcmd($user_input)); // Fuggi da personaggi pericolosi

La funzione escapeshellcmd() esegue l'escape del carattere * per evitare conseguenze catastrofiche dell'esecuzione del comando.

La sicurezza è uno degli aspetti più importanti della programmazione sul Web, quindi ho dedicato un intero capitolo a questo argomento e alla sua relazione con la programmazione PHP. Vedere il capitolo 16 per ulteriori informazioni.

Lavorare con il file system

PHP ha 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 passato. La sintassi per la funzione basename() è:

stringa nome_base(stringa nome_completo)

L'estrazione del nome file di base dal nome completo avviene come segue:

$percorso = "/usr/local/phppower/htdocs/index.php"; $file = nome base($percorso); // $file = "indice.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 della funzione getlastmod() è:

int getlastmod (vuoto)

Il valore restituito è conforme al formato data/ora UNIX ed è possibile utilizzare la funzione date() per formattarlo. Il seguente snippet stampa 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:

matrice stat(stringa nomefile)

Le seguenti informazioni vengono restituite negli elementi dell'array:

0 dispositivo

2 Modalità di protezione del nodo indice

3 Numero di collegamenti

4 ID utente proprietario

5 ID gruppo proprietario

6 Tipo di dispositivo inode

7 Dimensioni in byte

8 Ora dell'ultimo accesso

9 Ora dell'ultima modifica

10 Ora dell'ultima modifica

11 Dimensione del blocco per l'input/output nel file system

12 Numero di blocchi allocati

Pertanto, se vuoi sapere quando è stato effettuato l'ultimo accesso al file, guarda l'elemento 8 dell'array restituito. Considera un esempio:

$file - "datafile.txt";

list($dev, $inode, $inodep, $nlink, $uid, $gid, $inodev, $size, $atime, $mtime, $ctime,

$bsize) = stat($file);

print "$file è $byte di dimensione.
";

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

Ultima modifica: 15 agosto 2000 10:07:18

In questo esempio, ho usato il costrutto list() per nominare ogni valore restituito. Naturalmente, potresti anche restituire un array, scorrere gli elementi e visualizzare tutte le informazioni di cui hai bisogno. Come puoi vedere, la funzione stat() ti consente di ottenere varie informazioni utili su un file.

Visualizzazione e modifica delle caratteristiche dei file

Ogni file sui sistemi della famiglia UNIX ha tre caratteristiche importanti:

• appartenere a un gruppo;
• proprietario;
• permessi.

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 conosci i sistemi operativi UNIX, puoi trovare informazioni sulle caratteristiche del file system UNIX all'indirizzo http://sunsite.auc.dk/linux-newbie/FAQ2.htm. Gli argomenti della proprietà del gruppo, della proprietà e delle autorizzazioni sono trattati nella sezione 3.2.6.

La funzione chgrp() tenta di modificare il gruppo a cui appartiene il file specificato. Sintassi della funzione chgrp():

int chgrp (nome file stringa, gruppo misto)

La funzione filegroup() restituisce l'ID gruppo del proprietario del file con il nome dato, o FALSE in caso di errore. La sintassi della funzione filegroup() è:

int filegroup (stringa nomefile)

La funzione chmod() cambia i permessi di un file con il nome dato. La sintassi per la funzione chmod() è:

int chmod (stringa nomefile, int permessi)

I permessi sono specificati in ottale. Le specifiche dell'impostazione del parametro della 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 dato, o FALSE in caso di errore. La sintassi della funzione fileperms() è:

int fileperms (stringa nomefile)

La funzione chown() tenta di cambiare il proprietario di un file. Il diritto di modificare il proprietario di un file è concesso solo a un utente privilegiato. La sintassi della funzione chown() è:

int chown (nome file stringa, utente misto)

La funzione fileowner() restituisce l'ID utente per il proprietario del file con il nome specificato. La sintassi della funzione fileowner() è:

int fileowner (stringa nomefile)

Copiare e rinominare i 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: copy() e rename().

Copiare un file in uno script PHP è facile come usare il comando UNIX cp. Il problema è risolto dalla funzione copy() di PHP. La sintassi della funzione copy() è:

int copy (origine stringa, destinazione stringa)

La funzione copy() tenta di copiare il file di origine nel file di destinazione; restituisce VERO in caso di successo, FALSO in caso di errore. Se il file di destinazione non esiste, la funzione copy() lo crea. L'esempio seguente mostra come eseguire il backup di un file utilizzando la funzione copy():

$file_dati = "dati.txt";

copy($file_dati. $file_dati".bak") o die("Impossibile copiare $file_dati");

La funzione rename() rinomina un file. Restituisce VERO in caso di successo, FALSO in caso di errore. Sintassi della funzione rename():

bool rename (stringa vecchio_nome, stringa nuovo_nome)

Un esempio di rinominare un file con la funzione rename():

$file_dati = "dati.txt";

rinomina($file di dati, $file di dati".old") o muori ("Impossibile rinominare il file di dati di $");

Eliminazione di file

La funzione unlink() rimuove il file con il nome dato. Sintassi:

int unlink (file stringa)

Se stai lavorando con PHP su un sistema Windows, ci sono alcuni problemi quando usi questa funzione. In questo caso, puoi utilizzare la funzione system() sopra descritta ed eliminare il file con il comando DOS del:

system("del nomefile.txt");

Lavorare con le directory

Le funzioni PHP consentono di visualizzare il contenuto delle directory e di navigare attraverso di esse. Il Listato 7.8 mostra una tipica struttura di directory UNIX.

Listato 7.8. Tipica struttura di directory

La funzione dirname() completa basename() -- estrae il percorso dal nome file completo. Sintassi della funzione dirname():

stringa dirname (percorso della stringa)

Un esempio di utilizzo di dirname() per estrarre un percorso da un nome completo:

$percorso = "/usr/locla/phppower/htdocs/index.php";

$file = dirname($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 - dirname($SCRIPT_FILENAME);

La funzione is_dir() controlla se il file con il nome specificato è una directory:

bool is_dir (nome file stringa)

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 della funzione mkdir() è:

int mkdir (percorso stringa, modalità int)

Il parametro path specifica il percorso per creare la nuova directory. Non dimenticare di terminare il parametro con il nome della nuova directory! Il parametro mode determina le autorizzazioni assegnate alla directory creata.

Proprio come la funzione fopen() apre un handle per un dato file, la funzione opendir() apre un handle per una directory. La sintassi della funzione opendir() è:

int opendir (percorso della stringa)

La funzione closedir() chiude l'handle di directory passato come parametro. Sintassi della funzione closedir():

void closedir(int directory_manipulator)

La funzione readdir() restituisce l'elemento successivo della directory data. Sintassi:

stringa readdir(int directory_manipulator)

Con questa funzione, puoi facilmente elencare tutti i file e le sottodirectory nella directory corrente:

$dh = opendir(" .);

mentre ($file = readdir($dh)) :

print "$file
"; nel frattempo;

La funzione chdir() funziona esattamente come il comando UNIX cd, in quanto cambia nella directory specificata dal parametro. Sintassi della funzione chdir():

int chdir (directory di stringa)

Nell'esempio seguente, accediamo al libro/sottodirectory e ne visualizziamo il contenuto:

$nuovadir = "prenota";

chdir($newdir) o die("Impossibile cambiare nella directory ($newdir)"); $dh = opendir(" . ");

while ($file = readdir($dh)) ;

print "$file
";

La funzione rewlnddir() imposta il puntatore della posizione corrente all'inizio della directory aperta dalla funzione opendir(). Sintassi della funzione rewinddir():

void rewinddir(int dir_nipulator)

Progetto 1: un semplice contatore di colpi

Lo script presentato in questa sezione conta il numero di visite per la pagina in cui si trova. Prima di passare al codice nel Listato 7-9, rivedi l'algoritmo scritto in pseudocodice:

1. Impostare la variabile $access sul nome del file che memorizzerà il valore del contatore.
2. Usa la funzione file() per leggere il contenuto di $access nell'array $visits. Il prefisso @ prima del nome di una funzione elimina possibili errori (ad esempio, l'assenza di un file con il nome specificato).
3. Imposta la variabile $current_visitors sul valore del primo (e unico) elemento dell'array $visits.
4. Aumenta il valore di $current_visitors di 1.
5. Aprire il file $access per la scrittura e impostare il puntatore della posizione corrente all'inizio del file.
6. Scrivi il valore di $current_visitors nel file $access.
7. Chiudere il manipolatore facendo riferimento al file $access.

Listato 7.9. Semplice contatore di colpi

// Scenario: semplice contatore di colpi

// Scopo: salvare il numero di hit nel file

$accesso = "hits.txt"; // Il nome del file viene scelto arbitrariamente

$visitatori_correnti = $visite; // Recupera il primo (e unico) elemento

++$ visitatori_correnti; // Incrementa il numero di hit

$fh = fopen($accesso. "w"); // Apri il file hits.txt e imposta

// puntatore alla posizione corrente all'inizio del file

@fwrite($fh, $current_visitors);// Scrivi un nuovo valore del contatore

// per archiviare "hits.txt"

fclose($fh); // Chiude l'handle del file "hits.txt"

Progetto 2: costruzione di una mappa del sito

Lo script nel Listato 7-10 costruisce una mappa del sito, una rappresentazione gerarchica di tutte le cartelle e file sul server, a partire da una data directory. Per il calcolo dei rientri degli elementi che compongono la mappa del sito vengono utilizzate le funzioni definite in questo e nei precedenti capitoli. Prima di procedere al programma, rivedere l'algoritmo scritto in pseudocodice:

1. Dichiara le variabili di servizio per la memorizzazione della directory principale, 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).
2. Dichiara una funzione display_directory() che legge il contenuto di una directory e la formatta per la visualizzazione nel browser.
3. Costruire il percorso della directory concatenando il nome passato nella variabile $dir1 con $dir.
4. Apri una directory e leggi il suo contenuto. Formatta directory e nomi di file e visualizzali nel browser.
5. Se il file corrente è una directory, chiama ricorsivamente la funzione display_directory() e passale 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 la rientranza utilizzata nella formattazione).

Listato 7.10. programma sitemap.php

// File: sitemap.php

// Scopo: creare una mappa del sito

// Directory da cui iniziare a costruire la mappa

$beg_path = "C:\ProgrammiVApache Group\Apache\htdocs\phprecipes";

// File con un'immagine grafica della cartella.

// Il percorso deve essere relativo* alla directory principale del server Apache

$ folder_location = "C:\Documenti\PHP per programmatori\FINAL CHPS\grafica\cartella.gif";

// Testo nel titolo della finestra $page_name = "PHPRecipes SiteMap";

// Su quale sistema verrà utilizzato lo script: Linux o Windows?

// (0 - Windows; 1 - Linux)

$usandojinux = 0;

// Funzione: display_directory

// Scopo: legge il contenuto della directory specificata dal parametro

// $dir1, seguito dalla formattazione della gerarchia di directory e file.

// La funzione può essere chiamata ricorsivamente.

function display_directory ($ dir1, $ folder_location, $ using_linux, $ init_depth) (

// Aggiorna percorso

sdh = opendir($dir);

while($file = readdir($dh)) :

// Elementi delle directory "." e ".." non vengono emessi.

if (($file != ".") && ($file != "..")) :

se ($using_linux == 0):

$profondità = esplode("\\", $dir): else:

$profondità = esplode("/", $dir); finisci se; $curtent_depth = dimensionedi($profondità);

// Costruisci il percorso secondo le regole del sistema operativo utilizzato. se ($using_linux == 0):

$profondità_tab = $reparto_corrente - $profondità_inizializzazione;

$file = $dir. "\\", $file; altro:

$file = $dir. "/",$file; finisci se;

// La variabile $file contiene una directory? if (è dir($file)) :

// Calcola il riempimento

mentre ($x< ($tab_depth * 2)) :

$x++; nel frattempo;

Stampa"

".nomebase($file)."
";

// Incrementa il contatore

// Chiamata ricorsiva alla funzione display_directory()

display_directory($file, $posizione_cartella, $utilizzo_linux, $init_profondità);

// Non una directory

// Costruisci il percorso secondo le regole dell'usato

// sistema operativo.

se ($using_linux == 0):

$tab_depth = ($current_depth - $init_depth) - 2; $x = 0;

// Calcola il riempimento

mentre ($x< (($tab_depth * 2) + 5)) :

Stampa" ".nomebase($file)."
";

Stampa" ".nomebase($file)."
";

finisci se; // Is_dir(file) endif: // Se ! "." o ".."

// Chiudi la directory closedir($dh);

// Calcola il riempimento iniziale

se ($using_linux == 0):

$profondità = esplode("\\", $beg_path);

$profondità = esplode("/", $beg_path);

$init_profondità = dimensionedi($profondità);

display_directory($beg_path, $folder_location, $using_linux, $init_depth);

Sulla fig. La Figura 7.1 mostra l'output dello script per un catalogo con diversi capitoli in questo libro.

Riso. 7.1. Visualizzazione della struttura delle directory sul server utilizzando lo script sitemap.php

Risultati

Questo capitolo ha introdotto molti degli strumenti PHP per lavorare con i file. In particolare, abbiamo considerato le seguenti domande:

• verificare l'esistenza di file;
• aprire e chiudere file e flussi di input/output;
• scrivere su un file e leggerlo;
• reindirizzare il file al flusso di output;
• lanciare programmi esterni;
• operazioni del file system.

Il materiale in questo capitolo prepara le basi per il prossimo capitolo, Stringhe ed espressioni regolari, poiché l'elaborazione delle stringhe e le operazioni di I/O sono strettamente correlate nello sviluppo di applicazioni web.

Ultimo aggiornamento: 1.11.2015

Come la maggior parte dei linguaggi di programmazione, PHP supporta i file, che sono un modo per memorizzare le informazioni.

Lettura e scrittura di file

Apertura e chiusura di file

La funzione fopen() è definita in PHP per aprire i file. Ha la seguente definizione: risorsa fopen(string $filename, string $mode) . Il primo parametro $filename rappresenta il percorso del file e il secondo parametro rappresenta la modalità di apertura. A seconda dello scopo dell'apertura e del tipo di file, questo parametro può assumere i seguenti valori:

"r" : Il file viene aperto in sola lettura. Se il file non esiste, restituisce false

"r+" : Il file viene aperto come di sola lettura e scrivibile. Se il file non esiste, restituisce false

"w" : Il file viene aperto per la scrittura. Se tale file esiste già, viene sovrascritto, in caso contrario, viene creato.

"w+" : Il file viene aperto per la scrittura con leggibilità. Se tale file esiste già, viene sovrascritto, in caso contrario, viene creato.

"a" : Il file viene aperto per la scrittura. Se tale file esiste già, i dati vengono scritti alla fine del file e i vecchi dati rimangono. Se il file non esiste, viene creato

"a+" : Il file viene aperto per la lettura e la scrittura. Se il file esiste già, i dati vengono aggiunti alla fine del file. Se il file non esiste, viene creato

Il risultato della funzione fopen è un descrittore di file. Questa maniglia viene utilizzata per le operazioni sul file e per chiuderlo.

Al termine, il file deve essere chiuso utilizzando la funzione fclose(), che accetta un descrittore di file come parametro. Ad esempio, apriamo e chiudiamo un file:

$fd = fopen("form.php", "r") o die("Impossibile aprire il file"); fclose($fd);

Il costrutto or die("testo di errore") consente di terminare lo script e visualizzare alcuni messaggi di errore se la funzione fopen non è stata in grado di aprire il file.

Lettura di un file

Diverse funzioni possono essere utilizzate per leggere un file. Per la lettura riga per riga, viene utilizzata la funzione fgets(), che accetta un descrittore di file e restituisce una riga di lettura. Andiamo riga per riga attraverso l'intero file:

Ogni volta che chiami fgets() , PHP posizionerà un puntatore alla fine della stringa letta. Per tenere traccia della fine di un file, viene utilizzata la funzione feof(), che restituisce true al termine del file. E finché non viene raggiunta la fine del file, possiamo usare la funzione fgets().

Lettura dell'intero file

In questo caso, non è necessario aprire in modo esplicito il file, ottenere un handle e quindi chiudere il file.

Blocca lettura

Puoi anche eseguire una lettura blocco per blocco, ovvero leggere un certo numero di byte da un file usando la funzione fread():

La funzione fread() accetta due parametri: il descrittore di file da leggere e il numero di byte da leggere. Durante la lettura di un blocco, il puntatore nel file si sposta alla fine di questo blocco. E anche con l'aiuto della funzione feof(), puoi monitorare il completamento del file.

Scrivi file

Per scrivere un file, viene utilizzata la funzione fwrite(), che scrive una stringa nel file:

Un'altra funzione fputs() funziona in modo simile:

Lavorare con il puntatore di file

Quando si apre un file per la lettura o la scrittura in modalità "w", il puntatore nel file viene posizionato all'inizio. Durante la lettura dei dati, PHP sposta il puntatore nel file alla fine del blocco di dati letti. Tuttavia, possiamo anche manipolare manualmente il puntatore nel file e impostarlo su una posizione arbitraria. Per questo è necessario utilizzare la funzione fseek, che ha la seguente definizione formale:

int fseek (risorsa $ handle , int $ offset [, int $ da dove = SEEK_SET ])

Il parametro $handle rappresenta un handle di file. Il parametro $offset è l'offset in byte relativo all'inizio del file da cui inizierà la lettura/scrittura. Il terzo parametro opzionale specifica come impostare l'offset. Può assumere tre valori:

SEEK_SET : valore predefinito, imposta l'offset per compensare i byte dall'inizio del file

SEEK_CUR : imposta l'offset sui byte di offset rispetto all'inizio della posizione corrente nel file

SEEK_END : imposta l'offset per sfalsare i byte dalla fine del file

La funzione fseek() restituisce 0 se il puntatore è impostato correttamente e -1 se fallisce.

Un esempio di utilizzo della funzione:

$fd = fopen("hello.txt", "w+") o die("Impossibile aprire il file"); $str = "Ciao mondo!"; // stringa da scrivere fwrite($fd, $str); // scrivi la stringa all'inizio fseek($fd, 0); // mette il puntatore del file all'inizio fwrite($fd, "Oink"); // scrivi la riga all'inizio fseek($fd, 0, SEEK_END); // metti il ​​puntatore alla fine fwrite($fd, $str); // scrivi un'altra riga alla fine fclose($fd);

download $_ (8)

Ho bisogno di caricare un file PHP in una variabile. Ad esempio include();

Ho caricato un semplice file html come questo:

$Vdata = file_get_contents("file di testo.txt");

Ma ora ho bisogno di caricare un file PHP.

Risposte

Se il tuo file ha una dichiarazione di ritorno:

"Afeganistão", "ZA" => "África do Sul", ... "ZW" => "Zimbabué");

Puoi ottenere questa variabile in questo modo:

$dati = include $percorsofile;

In alternativa, puoi avviare il buffering dell'output, eseguire un include / require e quindi interrompere il buffering. Con ob_get_contents() puoi semplicemente ottenere cose che sono state emesse da un altro file PHP in una variabile.

Se desideri scaricare un file senza eseguirlo tramite un server Web, dovrebbe funzionare quanto segue.

$stringa = eval(file_get_contents("file.php"));

Quindi verrà caricato il contenuto del file. Il file PHP deve essere completamente formato con i tagPer eval per valutarlo.

Immagino cosa vuoi ottenere Contenuto generato da PHP, se è così:

$Vdata = file_get_contents("http://IL TUO_HOST/IL TUO/FILE.php");

Altrimenti, se vuoi Codice sorgente del file PHP, questo è lo stesso del file .txt:

$Vdata = file_get_contents("percorso/del/TUO/FILE.php");

In teoria potresti semplicemente usare fopen e poi usare stream_get_contents.

$stream = fopen("file.php","r"); $stringa = stream_get_contents($stream); fclose($flusso);

Se stai usando http://, come suggerito da eyel, sarai in grado di leggere solo l'output dello script PHP. Puoi leggere uno script PHP solo se si trova sullo stesso server del tuo script. Quindi puoi usare qualcosa di simile

$Vdata = file_get_contents("/percorso/del/tuo/file.php");

Ecco come lo faccio (ci sono molti modi):

1. Conversione dati in JSON
2. chiamata AJAX per ottenere un file JSON
3. trasformazione JSON in un oggetto javascript

PASSO 1

connect_error) ( die("Connessione fallita: " . $conn->connect_error); ) $sql = "SELEZIONARE ID, nome,immagine DAL telefono"; $risultato = $conn->query($sql); while($riga =$risultato->fetch_assoc())($v=$riga; ) echo json_encode($v); $conn->chiudi(); ?>

PASSO 2

Funzione showUser(fnc) ( var xhttp = new XMLHttpRequest(); xhttp.onreadystatechange = function() ( if (this.readyState == 4 && this.status == 200) ( // PASSO 3 var p=JSON.parse( this.responseText);) ) )

(PHP 4 >= 4.3.0, PHP 5, PHP 7)

file_get_contents- Legge il contenuto di un file in una stringa

Descrizione

Corda file_get_contents (stringa $nomefile [, bool $use_include_path = falso [, risorsa $contesto [, int $ offset = -1 [, int $ maxlen ]]]])

Questa funzione è simile alla funzione file() con l'unica differenza che file_get_contents() restituisce il contenuto del file in una stringa, a partire dall'offset specificato e fino a maxlen byte. In caso di fallimento, file_get_contents() tornerà FALSO.

Uso delle funzioni file_get_contents()è preferibile se è necessario ottenere l'intero contenuto del file, perché per migliorare le prestazioni, la funzione utilizza la tecnica della mappatura del file in memoria (mappatura della memoria), se supportata dal sistema operativo.

Commento:

Se apri un URI contenente caratteri speciali come uno spazio, devi codificare l'URI con codice URL().

Elenco parametri

Il nome del file in lettura.

Usa_include_percorso

Commento:

Da PHP 5, puoi usare la costante FILE_USE_INCLUDE_PATH per cercare un file nel percorso di inclusione.

contesto

Risorsa di contesto valida creata dalla funzione stream_context_create(). Se non è necessario utilizzare un contesto speciale, è possibile saltare questo parametro passandogli il valore NULLO.

L'offset da cui iniziare a leggere il flusso originale.

La ricerca offset non è supportata quando si lavora con file remoti. Il tentativo di trovare un offset su file non locali può funzionare per piccoli offset, ma questo risultato è imprevedibile poiché opera su un flusso bufferizzato.

La dimensione massima dei dati da leggere. L'impostazione predefinita è leggere fino al raggiungimento della fine del file. Tieni presente che questa impostazione si applica anche a uno stream con filtri.

Valori di ritorno

La funzione restituisce i dati letti o FALSO in caso di errore.

Attenzione

Questa funzione può restituire come booleana FALSO e un valore non booleano a cui viene eseguito il cast FALSO. Per ulteriori informazioni, vedere Tipo booleano. Utilizzare l'operatore === per verificare il valore restituito da questa funzione.

Errori

Verrà generato un errore di livello E_ATTENZIONE se non è possibile trovare il parametro filename, il parametro maxlength è inferiore a zero o la ricerca all'offset nel flusso non riesce.

Esempi

Esempio n. 1 Ottieni e visualizza il codice sorgente della home page del sito web

$homepage = file_get_contents("http://www.example.com/");
eco $homepage ;
?>

Esempio n. 2 Trovare file in include_path

// <= PHP 5
$file = file_get_contents("./people.txt" , vero);
// > PHP 5
$file = file_get_contents("./people.txt" , FILE_USE_INCLUDE_PATH );
?>

Esempio #3 Lettura di una sezione di un file

// Leggi 14 caratteri, a partire dal carattere 21
$sezione = file_get_contents ("./people.txt" , NULL , NULL , 20 , 14 );
var_dump($sezione);
?>

Il risultato dell'esecuzione di questo esempio sarà qualcosa del genere:

string(14) "lle Bjori Ro"

Beispiel #4 Utilizzo di contesti di streaming

// Crea un thread
$opzioni = array(
"http" =>array(
"metodo" => "OTTIENI" ,
"header" => "Accetta-lingua: en\r\n" .
"Cookie: foo=bar\r\n"
);

$contesto = stream_context_create($opts);

// Apri il file utilizzando le intestazioni HTTP impostate sopra
$file = file_get_contents ("http://www.example.com/" , false , $context );
?>

Chiudi_notifica . PHP lo segnalerà come "SSL: Fatal Protocol Error" nel momento in cui raggiungi la fine dei dati. Per aggirare questo problema, è necessario impostare error_reporting su un livello che escluda E_WARNING. Le versioni PHP 4.3.7 e precedenti possono rilevare che l'IIS problematico si trova sul lato server quando si apre un flusso utilizzando un wrapper https:// e non visualizza un avviso. Se stai usando fsockopen() per creare ssl:// socket, l'utente è responsabile dell'identificazione e della soppressione di questo avviso.