In questo file *.php sono racchiusi tutti i concetti base della programmazione
// INTRODUZIONE
PHP è un potentissimo linguaggio di scripting che consente di creare complesse applicazioni (WEB BASED) che girano cioè all'interno di un web server */
//Come si apre e chiude uno scrip php (TAG RENDERING)//
<?php
phpinfo(); //questo comando mostra la versione di php installata sul server
?>
//ogni stinga php è chiusa dal simbolo ";"
/* All'interno di un file .php è possibile alternare pozioni di semplice html e porzioni di script php, infatti, il php è un linguaggio HTML-embedded. In ogni caso il file dovrà essere salvato con esenzione *.php per funzionare corretamente */
<p>Questo è html</p>
<?php
echo "<p>Mentre questo è PHP!</p>";
?>
<html>
<head>
<title>PHP e HTML</title>
</head>
<body>
La mamma ha comprato <?php echo $mele; ?> al costo di <?php echo $euro; ?> l'una.<br/>
In totale ha speso <?php echo $totale; ?> Euro!
</body>
// FUNZIONI ECHO & PRINT
// Funzione echo e print per stampare a video un messaggio/testo //
<?php
print "Testo scritto con comando print";
echo "Mentre questo è scritto con comando echo";
?>
// COMMENTI
// Commenti allo script per memorizzare istruzione ed essere intelleggibile //
// E' possibile utilizzare sia i simboli // o #, scrivere accanto o un commento su più righe /* */ //
<?php
//Commento uso comando echo
echo "Ciao"; //commento accanto allo script echo
#Commento uso comando print
print "Ciao"; # commento accanto allo scrip echo
/* questo
commento
è su più
righe
*/
?>
//LE VARIABILI
/* Utilizzo delle variabili (simbolo dollaro)"$" il valore di essa viene assegnato con il simbolo (uguale) "=" */
/* La variabile può essere definita come un'area di memoria in cui vengono salvate delle informazioni che possono mutare durante la fase di elaborazione del programma stesso */
<?php
$variabile = "valore"; // il valore di una variabile può essere assegnato utilizzando le virgolette
$variabile = 'valore'; // Oppure utilizzando gli apici
$variabile = 1; // nel caso di un valore numerico non sarà necessario utilizzare le virgolette/apici
$valiabile = 1.5; // stessa cosa per i valori numerici decimali
?>
// LE COSTANTI
/* A differenza della variabile, che una volta definita può cambiare valore, la costante resta sempre uguale a se stessa ed ogni "tentativo" di cambiarne il valore produrrà un errore. */
// Funzione define()
<?php
define("Nome_costante","valore"); // E' possibile utilizzare, come nelle varibili, le virgolette
define('Nome_costante','valore'); // oppure degli apici
define('NOME_COSTANTE', 1); /* Nel caso di valore numerico, come nelle varibili, non servono virgolette o apici */
define('NOME_COSTANTE', 1.5); // stessa cosa vale per i valori numerici decimali
?>
// Per consetudine, qiuindi non obbligatoriamente, i numeri delle costanti vengono scritte in maiuscolo //
/* ATTENZIONE: Si noti che i nomi delle costanti, così come quelle delle varianti, sono "CASE-SENSITIVE", ovvero per essere richiamate è necessario rispettare se esse sono stante scritte precedentemente in maiuscolo o minuscolo */
/*E' anche possibile definire costanti "CASE-IN-SENSITIVE", in tal caso sarà sufficiente specificare 'true' come terzo paramentro nella funzione define(): */
<?php
define('NOME_COSTANTE','valore',true); /* Definisco una costante CASE-INSENSITIVE con il parametro 'true' */
echo NOME_COSTANTE; // Quindi questo sarà corretto
echo nome_costante; // così come questo
echo Nome_Costante; // ed anche questo
?>
/* Come è possibile notare qui sopra, le costanti sono utilizzabili nel codice PHP, semplicemente, mediante il proprio nome senza, cioè, il simbolo del dollaro che è tipico delle variabili. */
// OPERAZIONI NUMERICHE/MATEMATICHE IN PHP mediante gli "Operatori" //
/* Operatori disponibili:
"+" addizione
"-" sottrazione
"*" moltiplicazione
"/" divisione
"%" modulo
L'OPERATORE MODULO serve per calcolare il resto di una divisione. Esempio: */
<?php
$valore1 = 5;
$valore2 = 4;
echo "$valore % $valore2";
?>
/* il presente script mostrera come risultato "1" in quanto il 4 sta nel 5 una sola volta con il resto, appunto, di 1 */
/*ATTENZIONE: si noti che i valori NUEMRI INTERI vengono chiamati "integer", mentre i VALORI NUMERICI DECIMALI vengono chiamati "double"
//INCREMENTARE VALORE VARIABILI//
//PHP consente di incrementare con facilità il valore di una variabile//
<?php
$valore = 5;
$valore = $valore + 5; /* ora la nostra variabile avrà valore 10 e se richiamata manterrà questo ultimo valore */
?>
/* E' possibile scrive, divera sintassi, ma medesimo risultato
<?php
$valore = 5;
$valore += 5; /* come prima, ora la nostra variabile avrà valore 10 e se richiamata manterrà questo ultimo valore */
?>
/* PHP prevede delle scorciatoie per incrementare o decrementare di una unità una data variabile numerica */
<?php
$totale++; //il presente comando "++" aumenterà di 1 la nostra variabile
$totale--; //mentre "--" diminuirà di 1 la nostra variabile
?>
/* E' importante rispettare le regole matematiche ricordiamoci di rispettare le "le priorità" del calcolo matematico mediante un uso corretto delle parentesi */
<?php
$calcola = 5+7*2; // il presente calcolo darà un risultato
$calcola = (5+7)*2; // che è differente dal risultato che mostrà questa sintassi
?>
// OPERATORI DI CONFRONTO
/*Gli operatori di confronto consentono di effettuare dei confronti tra valori e di restituire un risultato che sarà o vero (true) o falso (false)*/
/* Operatori di confronto disponibili:
"==" uguale
"!=" diverso
"<" minore
">" maggiore
"<=" minore o uguale
">=" maggiore o uguale
*/
<?php
//Definisco due variabili
$a = 1;
$b = 2;
//Confronto le variabili tra loro con alcuni opertatori di confronto
$a == $b; // il risultato sarà FALSO
$a != $b; // il risultato sarà VERO
$a < $b; // il risultato sarà VERO
?>
/*Gli operatori di confronto operano anche con variabile di tipo stringa, quindi "testuali"
In questo caso il valore viene stabilito in base all'ordine alfabetico
"a" è minore di "b", "b" è minore di "c" ecc.
Inoltre tutte le lettere MINUSCOLE sono sempre considerate di "valore maggiore" rispetto alle lettere maiuscole
"a" è maggiore di "A"
Infine, bisogna ricordare che tutte le lettere (maiuscole e minuscole) sono considerate di "valore maggiore" rispetto ai numeri compresi tra 0 e 9
"a" è maggiore di 0, di 1, di 2, di 3, ecc.
UN CASO MOLTO PARTICOLARE
Quando confrontiamo una variabile di tipo "numerico" ed una di tipo "stinga" (testuale)
Php cercherà se all'inizio nel valore della STRIGA ci siano valori numerici, se lo trova,
le attribuirà quel valore numerico, in alternativa, le attibuirà un valore uguale a zero.
*/
<?php
//Definisco alcune variabili
$a = 1;
$b = 2;
$c = "2 tappi";
$d = "tappo";
$e = "A";
$f = "a";
//Confronto le variabili tra loro con alcuni opertatori di confronto
$a == $b; // FALSO 1 non è uguale a 2
$b != $c; // VERO 2 è diverso da 3 (considera solo il valore numerico)
$d < $e; // VERO la t è considerata maggiore di A (che è maiuscola)
$e > $f; // FALSO A (maiuscola) è minore di a (minuscola)
?>
// OPERATORI LOGICI
/Gli operatori logici servono per combinare, alternare o negare più valori booleani (true/false)./
/* Operatori logici disponibili:
"AND" (se questo e quasto sono veri) Tutte gli operatori devono essere veri
"&&" alias "AND"
"OR" (se questo o questo è vero) Almeno uno dei due operatori deve essere vero
"||" alias "OR"
"XOR" (se uno ma non l'atro è vero) Solo uno dei due operatori deve essere vero
"NOT (anche se e vero restituisci falso e vicevera) E' l'operatore di negazione e si usa con un solo operatore
<?php
(2 > 1) AND (1 == 1); // risultato VERO: entrambe le condizioni sono vere
(1 < 2) OR (1 > 2); // risultato VERO: la prima condizione è vera, la seconda no
NOT (1 < 2); // risultato FALSO: la negazione ribalta il valore
(1 < 2) XOR (2 > 1); // risultato FALSO: entrambe le condizioni sono vere mentre "XOR" ne vuole solo una
?>
//STUTTURE (costrutti) CONDIZIONALI: IF e ELSE
/* Strutture di controllo (costrutto) if / else, in italiano "se"..."altrimenti".
Il funzionamento è banale ma si tratta del costrutto più utilizzato in assoluto */
/* Le parentesi graffe si scrivono premendo ALT-GR + tasto maiuscolo e le parentesi quadre */
<?php
//Sintassi di if ed else
IF ($variabile == $variabile) { //se la prima variabile è uguale alla seconda
echo "messaggio di testo"; //mostra questo messaggio
}
ELSE //altrienti
{
echo "altro messaggio di testo"; //mostra questo
}
?>
//Se la condizione fosse su una sola riga non sarebbe necessario l'utilizzo della parentesi graffe//
<?php
IF ($variabile == $variabile) echo "messaggio di testo";
?>
<?php
IF ($variabile == $variabile) echo "messaggio di testo";
ELSE echo "altro messaggio di testo";
?>
//STRUTTURA NIDIFICATA (if & else) DI CONDIZIONI
/* Se la prima condizione è VERA se ne innesta una seconda. Qualora invece la prima condizione dovessee essere FALSA la seconda condizione non viene nemmeno verificata. */
<?php
if ($variabile1 == "1"){
if ($variabile2 == "2"){
echo "entrambe vere"; //visalizzerà questa risposta nel caso di ENTRAMBE le condizioni VERE
}else{
echo "solo la prima è vera"; //visualizzarà queta riposta nel caso in cui la PRIMA è VERA la SECONDA FALSA
}
}else{
echo "la prima è falsa"; // visualizzerà questa risposta nel caso in cui la PRIMA è FALSA (ed ignora la seconda )
}
?>
// STUTTURA CONDIZIONALE SWITCH
/* La struttura nidificata IF & ELSE vista in precedenza può essere realizzata mediante la sintassi dell'istruzione SWITCH */
<?php
switch ($VARIABILE) {
//se la variabile è uguale a 1
case 1:
echo "la variabile ha valore 1";
break;
//se la variabile è uguale a 2
case 2:
echo "la variabile ha valore 2";
break;
//se la variabile non ha valore 1 e non ha valore 2 e comunque in tutti gli altri casi
default:
echo "la variabile è un numero che non conosciamo";
}
?>
//ATTENZIONE: E' possibile indicare il "default" che indica a PHP il comportamento da tenersi qualora nessuna delle condizioni indicate sopra si realizzi. L'indicazione "default" può anche essere assente, ma quando c'è deve essere l'ultima della switch. //
// I CICLI
/* Nei linguaggi di programmazione esistono i cosiddetti cicli, ossia quando una determinata operazione (elemento) viene ripetuta per un certo numero di "x" di volte. Per il PHP, i cicli più importanti sono FOREACH, WHILE e FOR. */
// CICLO FOR (PER...)
// Sintassi (Struttura)//
<?php
for (istruzione1; istruzione2; istruzione3) {
echo "mostra risultato";
}
?>
/* Istruzione1: prendo una variabile e ne verifico il valore (TRUE-VERA)
Istruzione2: determino un limite entro il quale il processo non deve andare oltre
Istruzione3: incremento la variabile per fare paritire il ciclo */
//Esempio:
<?php
$variabile = 5; //Determino una variabile
for ($variabile = 5; $variabile <= 15; $variabile++) { //scirvendo "$variabile--" è possibile procedere al contrario
if ($variabile == 10) { //se la variabile è uguale a 10
continue; //SALTA questo valore; con "break" STOP-pi il processo
}
echo $variabile . " "; //Mostra risultati processo - spaziatura tra i vari risultati (. " ")
}
?>
//CICLO WHILE (FINCHE'...)
Il ciclo while azione un processo finchè una variabile è verificata (VERA).
//Sintassi :
<?php
$variabile = 1; //Determino una variabile
while ($variabile <= 10) { // Finché la $variabile è minore o uguale a 10
$variabile++; //incrementala
echo $variabile . " "; // mostrami i risultati
}
?>
//CICLO DO WHILE (FAI.. FINCHE'...)
/* Il ciclo do-while è del tutto simile a quello while, con la sola sostanziale differenza che l’espressione /istruzione operativa è posta alla fine del ciclo. */
//Sintassi:
<?php
$variabile = 2; //Determino una variabile
do { $variabile++; // FAI incrementare la variabile
echo $variabile; // mostrami i risultati (3, 4, 5, ecc.)
}
while ($variabile > 1); // finchè la variabile sarà maggiore di 1
if ($variabile==10){ // quando il valore sarà uguale a 10
break; // stoppa il processo (altrimenti si avvierebbe un loop infinito)
}
?>
//CICLO FOREACH (PER OGNIUNO...)
/* Riprendiamo l'argomentazione di questo ciclo dopo aver chiarito GLI ARRAY
//GLI ARRAY (o Vettori)
/* Un Array è una variabile contenente una pluralità di valori */
//Esempio:
<?php
$citta = array("Bari", "Milano", "Napoli", "Torino"); //distanziati con ","
?>
/* Come per le variabili "normali" i testi sono tra (" ") e mentre sono invece distanziati tra loro con (,);
Se fossero stati valori numerici (numeri) non sarebbe stato necessario inserire i valori tra (" ") */
//ATTENZIONE: PHP associa automaticamente a ciascuno dei valori che abbiamo elencato un indice numerico, a partire da 0
//Esempio:
<?php
$citta = array();
$citta[0] = "Bari";
$citta[1] = "Milano";
$citta[2] = "Napoli";
$citta[3] = "Torino";
?>
// Come nell'esempio precedente, avremmo anche pottuto scrivere un array manualmente (voce per voce)
/* Nel nostro esempio abbiamo utlizzato un array con indice numerico, tuttavia è opportuno ricordare che l'indice può essere anche di tipo stringa */
<?php
$cliente["azienda"] = "Microsoft";
$cliente["nome"] = "Bill";
$cliente["cognome"] = "Gates";
?>
/* Quando l'indice è di tipo stringa si usano gli apici anche all'interno della parentesi quadra */
//RICHIAMARE SINGOLO VALORE ARRAY
Per riferirsi ad un singolo elemento dell'array si indica il nome dell'array seguito dall'indice
//Esempio:
<?php
echo "Ho visitato la città di " . $citta[1]; // Mostrerà "Ho visitato la città di Milano
?>
//AGGIUNGERE UN ELEMENTO AL NOSTRO ARRAY
Per aggiungere un nuovo elemento alla nostra array si usa
<?php
$citta[] = "Bologna";
?>
//ATTENZIONE:
Questo nuovo elemento verrà posizionato in coda al nostro array ed assumerà l'indice 4 $citta[4] = "Bologna";
//SOSTITUIRE UN VALORE GIA' ESISTENTE NEL NOSTRO ARRAY
<?php
$citta[4] = "Praga";
?>
/* in quanto "variabili" se io assegno ad una variabile esistente un valore differente con il simbolo "=", essa da quel momento in poi sarà uguale al valore assegnato in ultimo */
//ELIMINARE UN ELEMENTO/VALORE DAL NOSTRO ARRAY
<?php
unset($citta[4]);
?>
//CONTARE I VALORI CONTENUTI ALL'INTERNO DEL NOSTRO ARRAY
<?php
$quante_citta = count($citta);
?>
//Esempio CICLARE DEI RISULTATI CON LA FUNZIONE FOR
<?php
$variabile == 0; // Definisco una variabile uguale al valore 0 (zero)
$citta = array("Bari", "Milano", "Napoli", "Roma"); // Scirvo un array
$quante_citta = count($citta); // Conto i valori presenti nel precedente array (valore numerico)
for ($variabile=0; $vairabile<$quante_citta; $variabile++)
// Verifico la prima variabile, impongo un limite/verifico una condizione, infine la incremento //
{
echo $citta[$variabile] . "<br/>"; // Elenco andando a capo tutte le città
}
?>
// FUNZIONE FOREACH *posticipata precedentemente
/* Lo stesso risultato con una funzione molto più immediata e semplice, lo si può ottenere con la funzione FOREACH (PER OGNUNO...) */
//Esempio CICLARE DEI RISULTATI CON LA FUNZIONE FOR
<?php
$citta = array("Bari", "Milano", "Napoli", "Roma"); // Scirvo un array
foreach($citta as $paese) // Per ogniuno dei valori dell'erray assegno la variabile paese
{
echo $paese . "<br/>"; // Elenco "in automatico" tutti i valori dell'array citta attribuendoli la variabile paese
}
?>
//ATTENZIONE: Questo è possibile in quanto la funzione FOREACH in automatico conta i valori contenuti nel nostro array //
//VARIABILI GET e POST
Attraverso le variabili GET e POST è possibile passare (al server) informazioni/richieste o preferenze attraverso i form (moduli html)
//Variabile $_GET
Con il metodo GET i dati vengono passati direttamente all'interno dell'indirizzo web (URL) questa tipologia di passaggio dei dati viene detta QueryString;
Esempio:
http://www.sito.com/automobili.php?marca=fiat&modello=panda
Nota: apre con "?" seguito dai dati "nome=valore" ed in caso di più variabli esse saranno unite dal simbolo "&";
Esempio:
// Come si inviano le istruzioni:
<html>
<form method="get" action="file.php"> // Con GET i risultati saranno scritti nella QueryString
Testo: <input type="text" name="nome">
<input type="submit" name="submit" value="invia">
</form>
</html>
//Come si recuperano le istruzioni:
<?php
$variabile = $_GET['testo']; // Recupero il valore del parametro dalla QueryString
echo "Hai scritto questo: " . $variabile; // Ora stampo semplicemente a video il risultato
?>
// Variabile $_POST
Diversamente dalla variabile $_GET, per quanto simili, la variabile $_POST invia i dati al server (memorizza) ed essi non saranno visibili nella QueryString e quindi neanche all'utente.
// Come si inviano le istruzioni:
<html>
<form method="post" action="file.php"> // Con POST i risultati saranno inviati al server
Testo: <input type="text" name="nome">
<input type="submit" name="submit" value="invia">
</form>
</html>
//Come si recuperano le istruzioni:
<?php
$variabile = $_POST['testo']; // Recupero il valore dal server
echo "Hai scritto questo: " . $variabile; // Ora stampo a video il risultato
?>
//NOTE:
Settando l'impostazione "register_globals" su "on" sul file "php.ini" sarebbe possibile anche recuperare i dati in maniera più semplice, ovvero utilizzando il nome del campo preceduto dal simbolo del dollaro;
I corrispondenti $HTTP_GET_VARS e $HTTP_POST_VARS appartengono ad una versione precedente di php, anche se ancora utilizzabile è presumibile che vengano presto eliminati.
//PHP e MYSQL: Lavorare con i database
/* MySQL è un database veloce e potente in grado di gestire applicazioni web-based di grande criticità (impegno);
Per dovere di cronaca, anche se la scelta più diffusa è quella di MySQL, va evidenziato che PHP può dialogare con diversi sistemi di server come MySQL, MS Access, PostgreSql, Oracle, Microsoft Sql Server, Sybase ecc.
1. Connettersi al server MySQL
<?php
$connection=mysql_connect(server, utente, password) or die('Errore nel connetersi al server'); ;
?>
2. Chiudere connessione al server MySQL
<?php
mysql_close($connection); //E' buona abbitudine chiudere la connessione al termine dell'operazione
?>
3. Selezionare un Database specifico
<?php
mysql_select_db('nome_database', $connection) or die('Errore nel collegarsi al database');
?>
4. Effettuare una Query
/* Una volta collegatici al nostro database è possibile interrogarlo mediante delle query;
Le Query sono stringhe di comando in linguaggio-SQL, tramite il quale è possibile recuperare i dati contenuti nel database;
La funzione di cui avremo bisogno è la seguenta: mysql_query() */
<?php
$query = "SELECT * FROM tabella WHERE id > 10"; // questa è la nostra query d'interrogazione
$result = mysql_query($query, $connection) or die('La query è errata'); //così catturiamoi risultati
?>
//La variabile $connection è facoltativa, se omessa, verrà utilizzata l'ultima connessione aperta//
5. Leggere i record restituiti da una query di SELECT
/* Una volta recuperati(catturati) i record(risultati) dobbiamo ciclarli(stamparli) a video
A tal fine, utilizzeremo le funzioni mysql_num_rows() e mysql_fetch_rows() */
1. mysql_num_rows()
Serve per conteggiare il numero di records trovati all'interno del nostro db sulla base di una data query
2. mysql_fetch_row()
Recupera il contenuto dei records trovati e restituisce una array contenente i valori di ogni campo (riscontrato nel recordset) che potremo poi richiamare specificando il relativo indice numerico
3. mysql_fetch_assoc()
Del tutto simile a mysql_fetch_row(), con la differenza che esso sviluppata un array contenente i valori di ogni campo specificandone e organizzandoli, anzichè per indice numerico, secondo il nome del campo
4. mysql_fetch_array()
Infine c'è mysql_fetch_array() che supporta, indistintamente, entrambe le tecniche di chiamata
<?php
// Imposto una query SELECT
$query = "SELECT nome, cognome, telefono FROM tabella ORDER BY cognome ASC";
$result = mysql_query($query, $connection) or die('La query è errata');
// FROM da-nome della tabella; ORDER BY ordina secondo..; ASC ascendente / DESC discendente //
// Conto il numero di occorrenze(risultati concidenti con la query) trovate nel database
$numrows = mysql_num_rows($result);
/* Conto i valori coincidenti con la query mediante la funzione mysql_num_rows($result) è gli attribuisco la variabile $numrows (potrei anche cambiarli il nome)*/
// Se nel database non ho trovato occorrenze
if ($numrows == 0){ // Quindi $numrows è uguale a zero
echo "Il database è vuoto!"; // Mostro questo messaggio
}
else // altrimenti
{
$variabile = 0; // Fisso una variabile con valore pari a zero
// Avvio un ciclo FOR
for ($variabile = 0; $varibile < $numrows; $x++){
// Verifico una variabile; scrivo una condizione; incremento;
/* Recuperiamo il valore/contenuto di ogni record (per ora abbiamo solo un totale numerico di risultati) */
$resrow = mysql_fetch_row($result); //questo comando genera un array ad indice numerico
/* $resrow è il numero di risultati identificati, tramite la funzione mysql_fetch_row recupero i valori contenuti in essi, che sono ($result) risultati della query */
$nome = $resrow[0]; //NOME *questi sono i numeri dei campi, i valori sono ancora memorizzati e //saranno stampati a video dal comando echo
$cognome = $resrow[1]; //COGNOME
$telefono = $resrow[2]; //TELEFONO
//usando mysql_fetch_rows() abbiamo scritto...
//$nome = $resrow[0]; //indice numerico
//$cognome = $resrow[1]; //indice numerico
// ...usando mysql_fetch_assoc() avremmo scritto
//$nome = $resrow['nome']; //indice per campo di testo
//$cognome = $resrow['cognome']; //indice per campo di testo
// Stampo a video i risultati
echo "nome: <b>" . $nome . "</b><br/>";
echo "cognome: <b>" . $cognome . "</b><br/>";
echo "telefono: <b>" . $telefono . "</b>";
}
}
// Chiudo la connessione
mysql_close($connection);
?>
//Query SQL: INSERT INTO, UPDATE e DELETE
//INSERT INTO (Inserisci dentro..)
<?php
$query = "INSERT INTO tabella VALUES('valore1','valore2','valore3')";
$result = mysql_query($query, $connection) or die('Impossibile inserire i valori');
?>
// UPDATE
<?php
$query = "UPDATE tabella SET campo1='valore1', campo2='valore2', campo3='valore3' WHERE id = 1";
$result = mysql_query($query, $connection) or die('Impossibile aggiornare i valori');
?>
// DELETE
<?php
$query = "DELETE FROM tabella WHERE id = 1";
$result = mysql_query($query, $connection) or die('Impossibile cancellare i valori');
?>
AGGIORNAMENTO SINTASSI:
Per quanto riguarda la famiglia di funzioni mysqli_*, il passaggio è piuttosto semplice in quanto (mantenendo lo stile di programmazione procedurale) sarà sufficiente cambiare il prefisso "mysql_" in "mysqli_" per continuare ad utilizzare buona parte dei nostri vecchi script.
//Includere file con PHP: include() e require()
Molto utile all'interno del lingaggio php sono le funzioni incude (includi) e require (richiedi);
L'esempio più banale è quello in cui, se scrivessimo un file connessione.php dove sono eseguite le strighe di connessione al database esso sarebbe richiamabile in altri file php, quindi senza riscivere ogni volta il codice di connessione,in ogni file della nostra applicazione, tramite i comandi Include e require;
Sintassi:
<?php
include "connessione.php";
?>
<?php
require ("connessione.php");
?>
NOTE:
Si noti che sia include che require possono essere utilizzati, indifferentemente, con e senza le parentesi;
Si noti anche, che, affinchè l'inclusione vada a buon fine, è necessario specificare il percorso corretto del file che si desidera includere (nel nostro esempio il file "connessione.php" si trova nella stessa cartella degli script che lo includono).
I due comandi include e require producono il medesimo risultato; l'unica differenza consiste nella gestione di eventuali errori: nel caso il file da includere non si trovato include() genererà un warning mentre require() un fatal error (bloccando, di fatto, l'esecuzione dello script).
//Usare include_once e require_once
E' da segnalare l'esistenza di due interessanti varianti, si tratta dei comandi include_once e require_once. La loro fnzione è identica a include e require con l'unica differenza che prima di includere il file verificano che questo non sia già stato precedentemente incluso nella pagina ed, in tal caso, non fanno nulla.