Manuale PHP
Indietro | Capitolo 16. Strutture di controllo | Avanti

# include()

L'istruzione include() include e valuta il file specificato.

La documentazione seguente si applica anche a require(). I due costrutti sono identici in ogni aspetto eccetto per come essi trattano gli errori. include() produce un Warning mentre require() restituisce un Fatal Error. In altre parole, usate require() se volete che un file mancante fermi l'esecuzione della pagina. include() non si comporta in questo modo, lo script continuerà nonostante tutto. Assicuratevi di avere un appropriato include_path impostato a dovere. Attenzione che nelle versioni di PHP antecedenti la release 4.3.5 errori di parsing nei file inclusi non bloccavano l'esecuzione. Da questa versione lo fanno.

I file da includere sono prima cercati nella include_path relativa rispetto alla directory di lavoro e quindi nella include_path relativa alla directory dello script. Ad esempio, se la include_path è impostata a ., e la directory di lavoro corrente è `/www/`, si può includere `include/a.php` e qui vi è include "b.php", il file `b.php` verrà prima cercato in `/www/` e quindi in `/www/include/`. Se il nome del file inizia con ../, viene cercato solo nella include_path relativa alla directory di lavoro corrente.

Quando un file viene incluso, il codice che esso contiene eredita lo scope delle variabili della riga in cui si verifica l'inclusione. Qualsiasi variabile disponibile in quella riga nella chiamata al file sarà disponibile all'interno del file chiamato, da quel punto in avanti. Tuttavia tutte le funzioni a le classi definite all'interno di un file di include hanno visibilità glibale.

Esempio 16-5. Esempio di base con include()

`vars.php <?php $colore = 'verde'; $frutto = 'mela'; ?> test.php <?php echo "Una $frutto $colore"; // Una include 'vars.php'; echo "Una $frutto $colore"; // Una mela verde ?>`

Se l'inclusione si verifica dentro una funzione all'interno del file chiamato, allora tutto il codice contenuto nel file chiamato si comporterà come se esso sia stato definito all'interno di una funzione. Così, esso seguirà lo scope delle variabili di quella funzione.

Esempio 16-6. Inclusione all'interno di funzioni

`<?php function foo() { global $frutto; include 'vars.php'; echo "Una $frutto $colore"; } /* vars.php è nello scope di foo() così * * $colore NON è disponibile fuori di * * questo scope. $frutto si perchè è stato * * dichiarato globale. */ foo(); // Una mela verde echo "Una $frutto $colore"; // Una mela ?>`

Quando un file viene incluso, il parsing esce dalla modalità PHP e entra in modalità HTML all'inizio del file incluso, e riprende alla fine. Per questa ragione, qualunque codice all'interno del file incluso che dovrebbe essere eseguito come codice PHP deve essere incluso all'interno dei tag PHP validi di apertura e chiusura.

Se "URL fopen wrappers" nel PHP sono abilitati (come nella configurazione di default), potete specificare il file da includere usando un URL (via HTTP o altri wrapper supportati - vedere Appendice M per avere la lista dei protocolli supportati ) invece che un percorso locale. Se il server chiamato interpreta il file incluso come codice PHP, le variabili possono essere passate al file incluso usando una stringa di richiesta URL come con l'utilizzo di HTTP GET. Non è proprio parlare della stessa cosa includere il file e averlo ereditato dallo scope di variabili del file chiamante; lo script è stato attualmente eseguito su un server remoto e il risultato è poi stato incluso nello script locale.

Avvertimento
la versione per Windows di PHP antecedente la 4.3.0 non supporta l'accesso remoto ai file da parte di questa funzione, anche se allow_url_fopen è abilitato.

Esempio 16-7. include() attraverso HTTP

`<?php
/* Questo esempio assume che www.example.com è configurato per eseguire file
* .php e non file .txt. Anche, 'Funziona' qui significa che le variabili
* $foo e $bar sono disponibili all'interno del file incluso. */
// Non funzionerà; file.txt non è stato trattato da www.example.com come PHP
include 'http://www.example.com/file.txt?foo=1&bar=2';
// Non funzionerà; cercare un file chiamato'file.php?foo=1&bar=2' nel
// filesystem locale.
include 'file.php?foo=1&bar=2';
// Funziona.
include 'http://www.example.com/file.php?foo=1&bar=2';
$foo = 1;
$bar = 2;
include 'file.txt'; // Funziona.
include 'file.php'; // Funziona.
?>`

Vedere anche Remote files, fopen() e file() per informazioni correlate.

Poichè include() e require() sono speciali costrutti di linguaggio, dovete includerli all'interno di blocchi di istruzioni se si trovano in un blocco condizionale.

Esempio 16-8. include() e i blocchi condizionali

`<?php // Questo NON VA BENE e non funzionerà come desiderato. if ($condizione) include $file; else include $un_altro; // Questo è CORRETTO. if ($condizione) { include $file; } else { include $un_altro; } ?>`

Trattamento dei valori restituiti: È possibile eseguire un'istruzione return() in un file incluso per terminare l'esecuzione di quel file e restituirlo allo script che l'ha chiamato. È anche possibile restituire valori dai file inclusi. Potete prendere il valore di una chiamata di inclusione come fareste con una normale funzione. Tuttavia questo non è possibile quando si include file remoti, a meno che l'output del file remoto non contenga tag di inizio e fine codice validi in PHP (come i file locali). Si possono dichiarare variabili all'interno di questi tag e queste saranno inserite nel punto in cui il file è stato incluso.

Poichè include() è un costrutto del linguaggio speciale, non richiede le parentesi per i propri argomenti. Fare attenzione quando lo si confronta i valori restituiti.

Esempio 16-9. Confronto dei valori restituiti da include

`<?php // non funziona, viene trattato come include(('vars.php') == 'OK'), ad esempio. include('') if (include('vars.php') == 'OK') { echo 'OK'; } // funziona if ((include 'vars.php') == 'OK') { echo 'OK'; } ?>`

> Nota: In PHP 3, return potrebbe non apparire in un blocco a meno che esso sia un blocco di funzione, nel qual caso return() si applica a quella funzione e non all'intero file.

Esempio 16-10. include() and the return() statement

`return.php <?php $var = 'PHP'; return $var; ?> noreturn.php <?php $var = 'PHP'; ?> testreturns.php <?php $foo = include 'return.php'; echo $foo; // stampa 'PHP' $bar = include 'noreturn.php'; echo $bar; // stampa 1 ?>`

$bar ha valore 1 perchè l'inclusione è stata eseguita con successo. Notare la differenza tra gli esempi sopra. Il primo usa return() all'interno di un file incluso mentre l'altro no. Se il file non può essere incluso la funzione restituisce `FALSE` e genera un messaggio di E_WARNING

Se esistono funzioni definite nel file di include, queste possono essere utilizzate nel file principale a prescindere se esse siano prima o dopo il return(). Se un file viene incluso due volte, il PHP 5 genera un errore fatale, poichè le funzioni sono già dichiarate, mentre il PHP 4 non considera le funzioni dichiarate dopo il return(). Si raccomanda di utilizzare include_once() invece di verificare se un file è già stato incluso ed uscire tramite condizione dal file incluso.

Un'altro metodo per "includere" file PHP in una variabile consiste nel catturarne l'output tramite le funzioni di controllo dell'output ed include(). Ad esempio:

Esempio 16-11. Utilizzo del buffering dell'output per inserire un file PHP in una stringa

`<?php $string = get_include_contents('somefile.php'); function get_include_contents($filename) { if (is_file($filename)) { ob_start(); include $filename; $contents = ob_get_contents(); ob_end_clean(); return $contents; } return false; } ?>`

Per includere automaticamente dei file negli script vedere i parametri auto_prepend_file e auto_append_file nel `php.ini`.

> Nota: Poichè questo è un costrutto del linguaggio e non una funzione, non può essere chiamato con le variabili funzione

Vedere anche require(), require_once(), include_once(), readfile(), virtual(), e include_path.

Indietro | Partenza | Avanti
require() | Risali | require_once()