PHP + MYSQL Corso Facile Di Programmazione
PHP + MYSQL Corso Facile Di Programmazione
Questo Ebook è scritto interamente da Daniele Venditti in modo originale, è opera di ingegno tutelata per legge dal
diritto di autore.
LEZIONE 3… Il Database MySqL e lo strumento phpMyAdmin. Creazione di una tabella e inserimento dei dati
LEZIONE 4… Connessione al Database MySqL, ciclo WHILE, Funzione MYSQL_FETCH_ARRAY, Array, altre
istruzioni.
LEZIONE 5… Inserire i dati nel database da interfaccia web con l’istruzione INSERT
LEZIONE 8 Session – Realizzare una semplice area riservata con PHP e MySqL
PREFAZIONE
Il libro elettronico é scritto con un linguaggio chiaro e semplice anche adatto a
chi per la prima volta si avvicina a questi nuovi concetti di apprendimento…
pratico al 100% é formato da 8 lezioni utili per creare un sito web dinamico
con l’ausilio del database MySql. Il corso é corredato da esempi pratici per
l’inserimento, la modifica e l’eliminazione dei dati da interfaccia
web phpmyadmin collegata con database su server Linux. Sarete operativi già
dalla prima lezione perché il contenuto non é solo un Ebook ma un vero e
proprio corso online di informatica per il web…accessibile a tutti, economico,
professionale!
L’opera costituisce uno strumento indispensabile per chi vuole avvicinarsi, per
professione o per conoscenza personale, al settore dei Webmaster imparando a
realizzare pagine web dinamiche.
Al termine di ogni sezione il lettore sarà invitato ad eseguire delle
esercitazioni. Per questo motivo abbiamo trovato più appropriato dividere il
libro in Lezioni e non più comunemente in Capitoli.
Tutti i concetti elencati in questo E-book sono racchiusi anche in un video
corso (indipendente) prelevabile dal portale di:
www.corsi-online.it
BUONA LETTURA…
(Daniele Venditti)
www.progettimultimediali.com
www.corsi-online.it
LEZIONE 1
Introduzione al corso. Le basi della programmazione PHP.
funzionamento del linguaggio sul server. Configurazione di
uno spazio hosting con server Linux e database MySql.
Dalla figura precedente notiamo che gli elementi del sistema per il
funzionamento di un sito web dinamico sono tre:
- Il sito web che visualizziamo per mezzo del nostro Browser.
- Il server web Apache su computer con OS Linux, all’interno del
quale (Spazio Hosting) sono contenuti tutti i file per il funzionamento
del nostro sito web.
- Il database MySql collegato con il server all’interno del quale sono
contenute tutte le informazioni che verranno assemblate in tempo reale
nel momento in qui l’utente ne fa richiesta con il suo browser.
-
Lo Spazio Hosting
Uno strumento indispensabile per eseguire le esercitazioni contenute nel corso
di PHP MySql. Per il nostro lavoro utilizzeremo il Provider Altervista che
gratuitamente ci mette a disposizione un server linux online corredato da
database MysQL.
Dunque occorre creare un account (cioè registrarsi) sul sito del fornitore
raggiungibile dal seguente indirizzo url:
http://it.altervista.org
www.nome_scelto.altervista.org
Una Valida alternativa ad Altervista (che noi descriveremo nel corso online) è
XAMPP software gratuito e rilasciato per diversi sistemi operativi. Il software
consiste in un web server e database MySql che verrà istallato a livello locale.
Tutte le prove effettuate dunque gireranno all’interno del proprio computer.
Altro strumento di lavoro utile per il nostro lavoro è avere a disposizione un
comodo software FTP che ci consentirà di trasferire comodamente i file
all’interno dello spazio hosting. Ricordiamo comunque che questa non è
una operazione necessaria poiché i file possono essere trasferiti
comodamente attraverso un facile “web manager” direttamente dal
pannello di controllo di Altervista.
<html>
<head>
<title>La mia prima pagina web con PhP</title>
</head>
<body>
<? Echo “La mia prima pagina web in HTML con PHP”;?>
</body>
</html>
prima.php
Trasferiamo il file all’interno del server di Altervista per mezzo del comodo
“web manager” all’interno del pannello di controllo del nostro account. Dal
Pannello di controllo di Altervista clicchiamo su “Accedi” in corrispondenza
di “Gestione File”, quindi clicchiamo sul pulsante “Invia File” selezioniamo il
file dal nostro computer “prima.php” e inviamolo all’interno dello spazio
hosting.
A questo punto entriamo in una scheda del nostro Browser e digitiamo
l’indirizzo URL che punterà alla pagina PHP appena creata. Nel nostro caso
(voi sostituite l’indirizzo con il vostro nome utente):
http://www.amokve.altervita.org/prima.php
Figura 3: Risultato Finale
Se clicchiamo con il tasto destro all’interno della pagina per visualizzare il
codice sorgente HTML noteremo che non c’è traccia della riga in PHP inserita
nella pagina web. Dunque, il codice:
<? Echo “La mia prima pagina web in HTML con PHP”;?>
LEZIONE 2
Le Variabili, Il controllo di flusso if…else. Esercitazione
pratica (Controllo Login)
Figura 4: Funzionamento del client FTP Filezilla. Ogni provider indica con precisione la
cartella dentro la quale trasferire i file.
I dati che occorrono per effettuare un connessione FTP tramite File Zilla sono
i seguenti:
HOST: ftp.vostronome.altervista.org
NOME UTENTE: il nome utente di Altervista
PASSWORD: la password di Altervista
Tutti questi dati possono essere anche memorizzati in una comoda opzione di
FileZilla.
Le Variabili in PHP
Un aspetto importante nel linguaggio PHP e quello di “Variabile”. Al fine di
avere un codice più pulito ed intuitivo nel corso della programmazione, le
variabili rappresentano un aspetto dal quale non è possibile prescindere
(caratteristica questa comune a molti linguaggi di programmazione e non solo
al PHP).
La sintassi di una variabile in PHP è ad esempio rappresentata dal seguente
codice:
$variabile=”ciao”;
Da notare il simbolo del “$” che precede sempre il nome desiderato della
variabile. La variabile è dunque un contenitore di dati, nel nostro caso la
parola ciao.
Alcune caratteristiche della sintassi di una variabile è che questa:
- Non deve iniziare con uno spazio
- Non deve iniziare con un numero
- Gli spazi tra i nomi devono essere riempiti dal simbolo”_”
Eseguiamo in piccolo esempio per capire praticamente il concetto di variabile.
Analizziamo il seguente codice:
<?php
$nome=“Daniele”;
$cognome=“Venditti”;
$sitoweb=“www.corsi-online.it”;
echo “<center>Benvenuti nel mio sito web: $sitoweb </center>”;
echo “<br><center>Realizzato da $nome $cognome$ </center>”;
?>
Se mostriamo il codice sorgente della pagina non ci sarà traccia del codice
PHP ma tutto sarà trasformato in HTML (dunque il codice PHP viene
elaborato a livello del server e restituito all’utente finale sotto forma di
semplice HTML.
$nomecompleto=$nome. $cognome;
Sintassi per concatenare più variabili per mezzo del ”.” da riutilizzare in
diverse parti del codice di programmazione (Per le variabili concatenate non si
usano le “”).
Controlli di Flusso (IF…ELSE)
<?php
$nome=“Daniele”;
if($nome == “Mario”{
echo “Il nome è Mario”;
else “Il nome non è Mario”;}
?>
Salvando il nostro lavoro con il nome prova2.php e trasferiamolo all’interno del server di
Altervista. Il risultato finale sarà “il nome non è Mario”.
Eseguiamo adesso un esempio più complesso delle nozioni descritte precedentemente (un
login con nome utente e password):
<html>
<head>
<title>Esempio semplice di Login</title>
</head>
<body>
<form action=“login.php” method=“post”>
Username: <input name=“user” type=“text”/>
Password: <input name=“pass” type=“text”/>
<input type=“submit” value=“Accedi”>
</form>
</body>
</html>
LEZIONE 3
Il Database MySqL e lo strumento phpMyAdmin. Creazione
di una tabella e inserimento dei dati
Nella schermata successiva, rappresentata dalla figura 10, è da notare il codice in puro
SQL, che noi abbiamo omesso di scrivere, perché aiutati dall’interfaccia grafica di
phpMyAdmin per mezzo del quale è possibile gestire tutto il database.
Cliccando sulla voce di menu “inserisci” (in alto) provvediamo a inserire i dati all’interno
dei record della nostra tabella.
Figura 11: Inserimento dati.
I dati possono essere inseriti singolarmente, oppure in blocco deselezionando l’opzione
“Ignora” come in fugura 11. Clicchiamo su Esegui. Per visualizzare i dati inseriti, andare
sulla voce “Mostra” nel menu superiore:
LEZIONE 4
Connessione al Database MySqL, ciclo WHILE, Funzione
MYSQL_FETCH_ARRAY, Array, altre istruzioni.
Figura 13: Parametri di connessione al database MySqL
Come collegare i file php ad database MySqL?
Questa è la naturale domanda che ci poniamo dopo aver appreso gli elementi delle lezioni
precedenti. Abbiamo parlato di file in php, abbiamo parlato di database MySqL e
dell’applicazione utile alla sua gestione che è phpMyAdmin adesso analizziamo come
trasferire le informazioni da php al database.
L’immagine precedente rappresenta la sintesi di questo procedimento illustrando gli
elementi che bisogna conoscere per unire php al database MySqL.
I parametri descritti nell’immagine precedente ci vengono assegnati automaticamente dal
Provider (dunque nel nostro caso Altervista). Per recuperarli entriamo all’interno del
pannello di controllo di Altervista, dalla Bacheca clicchiamo su “Gestisci Database” e
visualizzeremo tutti i parametri necessari per collegare php con il database del nostro
Provider (Credenziali di accesso).
Di seguito una serie di funzioni in php che utilizzeremo all’interno del codice per gestire
la connessione con un database mysql:
Figura 14: funzione di connessione (mysql_connect) e funzione di selezione del database
(mysql_select_db).
Figura 15: Gestione degli errori di collegamento (apertura connessione o selezione del
database)
<?php
//Dichiarazioni variabili per la connessione al database
$host = ‘localhost’;
$user = ‘amokve’;
$password = ”;
$database = ‘my_amokve’;
// Connessione al database server
$connessione= mysql_connect($host, $user, $password) or die (“impossibile
connettersi al server”);
// Selezione del database
mysql_select_db($database) or die (“impossibile connettersi al database
$database”);
// Creazione interrogazione al database
$query =“SELECT * FROM utenti”;
while($dati = mysql_fetch_array($risultato))
{
echo “Id utente: “.$dati[‘IdUtente’].“<br/>”;
echo “user: “.$dati[‘User’].“<br/>”;
echo “password: “ . $dati[‘Password’].“<br/><br/>”;
}
?>
Tutti gli elementi del listato che sono preceduti dal simlolo “//” introducono un commento
cioè una spiegazione di ciò che si vuole realizzare con una parte di codice. Non vengono
elaborati dall’interprete php ma servono solo per dare ordine e organizzazione a tutto il
codice in php, magari in corrispondenza di un listato complesso per numero di righe
(questa è una caratteristica comune a molti linguaggi di programmazione). Esempio:
//Dichiarazioni variabili per la connessione al database
Le istruzioni successive del nostro codice stabiliscono le variabili per la connessione con
il database MySqL:
$host = ‘localhost’;
$user = ‘amokve’;
$password = ”;
$database = ‘my_amokve’;
Come indicato in precedenza questi dati ci vengono forniti dal Provider (dunque
Altervista). Da notare il campo “password” del database che può essere lasciato vuoto.
Abbiamo racchiuso queste informazioni all’interno di variabili che utilizzeremo nei
passaggi successivi.
Stesso significato della funzione precedente solo che qui viene identificato il database
specifico che stiamo utilizzando attraverso la funzione “mysql_select_db”. Dunque
abbiamo due tipi di connessioni: Quella al server MySqL e quella al Database specifico
contenuto nel server.
Con questa istruzione racchiusa nella variabile “$query” viene eseguita una ricerca o
interrogazione (query) selezionando la tabella “utenti” del nostro database. Da notare
che il codice “SELECT * FROM utenti” costituisce un tipico esempio di istruzione Sql
(cioè il linguaggio che serve a gestire i database). In particolare questa istruzione si
traduce nel seguente modo:
SELECT (seleziona)
* (Tutti i campi – questo è il significato dell’asterisco)
FROM (dalla tabella)
utenti (il nome della nostra tabella)
Con questa parte di codice stampiamo (o meglio visualizziamo a video) i dati estrapolati
dal database mysql. Notiamo:
Ciclo “While” e la funzione:
mysql_fetch_array
che meritano degli approfondimenti.
Nella figura 17 sono rappresentati tutti i dati che si trovano nella tabella mysql (e che
anche voi potete provare a inserire utilizzando le istruzioni delle lezioni precedenti), e che
vengono riproposti dalla funzione MYSQL_FETCH_ARRAY al linguaggio PHP. In
pratica questa funzione prende i dati contenuti nella tabella trasformandoli in istruzioni
comprensibili per il PHP che in questo caso viene a conoscenza dell’esistenza di una
tabella con dati da elaborare all’interno del database mysql (se volessimo fare un
paragone, la funzione, è come se fosse una specie di specchio che riflette al php i dati
contenuti nella tabella del database).
Tutti i dati contenuti nella tabella ricreata dalla funzione MYSQL_FETCH_ARRAY sono
letti dal php riga per riga (ovvero record per record) e questa azione è svolta dalla
funzione del ciclo WHILE.
Dunque nell’ultima parte del nostro listato, il ciclo WHILE legge i dati contenuti nella
tabella e contenuti nella variabile “$dati” e mostrerà a video i risultati del primo record
della tabella. L’istruzione “echo” serve appunto a mostre a video (si dice impropriamente
stampare) i dati contenuti nel record.
Il ciclo WHILE non si fermerà fino a quando terminerà di leggere i record contenuti nella
tabella generati dalla funzione MYSQL_FETCH_ARRAY.
Una nota…l’istruzione <br/> è tipica del linguaggio html e serve per mandare a capo le
istruzioni. Per questo motivo i dati a video verranno mostrai in colonna.
Salviamo il file del listato precedente con il nome “leggitutto.php” e portiamolo
all’interno del server di Altervista.
A questo punto apriamo l’indirizzo URL corrispondente al file appena caricato. Esempio:
www.vostronome.altervista.org/leggitutto.php
Figura 18: Risultato finale mostrato a video – esiste uno spazio maggiore fra i record
perché nel listato abbiamo inserito un doppio <br/> nell’ultima istruzione.
Array (Vettore)
<?php
$nome = array(‘sara ‘,‘luca ‘,‘sandra ‘);
$conta = count($nome);
for($a=0;$a<$conta;$a++){
echo $nome[$a].‘<br/>’;
}
?>
Un Array è una variabile complessa dove le informazioni sono immagazzinate in una
struttura di tipo chiave o indice che corrisponde ad un determinato valore.
Per esempio il codice precedente rappresenta un Vettore. In particolare:
Nella variabile “$nome” è stato creato un vettore contenente tre nomi. Scrivere un codice
in questo modo viene interpretato dal php nel seguente modo:
<?php
$nome[0]=‘sara’;
$nome[1]=‘luca’;
$nome[2]=‘sandra’;
?>
Un Array o Vettore può essere costruito anche in altri modi. Abbiamo preferito questa
sintassi in quanto sono stati introdotti nel codice nuove istruzioni in php come la funzione
“count” o il “ciclo for”
$conta = count($nome);
Nel codice, la variabile “$conta” deve risultare uguale alla funzione “count ($nome)”,
funzione che conteggia tutti gli elementi contenuti nel vettore e racchiusi nella variabile
“$nome”
In seguito abbiamo inserito un ciclo for che come concetto è simile al ciclo While che
abbiamo descritto precedentemente (anche se la sintassi del codice è leggermente diversa):
for($a=0;$a<$conta;$a++){
echo $nome[$a].‘<br/>’;
}
Il ciclo for va a leggere ciclicamente i dati contenuti nel vettore e con l’istruzione echo
mostra a video i risultati di questa lettura.
In particolare nel ciclo for abbiamo dichiarato una nuova variabile “$a=0” (perchè questo
è il primo indice numerico che rappresenta la prima informazione del vettore - sara) e se
questa variabile (zero nel primo ciclo for) è minore dei valori contenuti nel vettore e
rappresentati dalla variabile “$conta” (che rappresenta tre valori nel nostro caso), la
variabile “$a” sarà ulteriormente incrementata tramite l’istruzione “$a++” fino a quando
non raggiungerà lo stesso indice dei valori contenuti nell’array.
Salviamo il codice iniziale del vettore con il nome “array.php” e trasferiamolo all’interno
dello spazio hosting di Altervista. Puntiamo il browser sul file ed otterremo il seguente
risultato:
sara
luca
sandra
Ci sono invece casi di Array associativi dove l’indice dei dati non è rappresentato da
numeri bensì da stringhe (cioè da testo). E’ il caso ad esempio del vettore generato dalla
funzione mysql_fetch_array già incontrata, dove gli indici sono rappresentati dai nomi
dei campi della tabella del database.
nome1–sara
nome2–luca
nome3–sandra
LEZIONE 5
Inserire i dati nel database da interfaccia web con
l’istruzione INSERT
In questa lezione procederemo all’inserimento dei dati nel database MySqL da interfaccia
web, adattando a tale scopo il modulo login.html incontrato all’inizio del nostro percorso.
Prendiamo il file login.html ed effettuiamo una copia. Rinominiamo il nuovo file in
insert.html e adattiamo il nuovo modulo per inserire i dati nel database.
In basso il codice del modulo insert.html (modificato), simile al form login.html
Questo file va salvato e caricato nello spazio hosting.
<html>
<head>
<title>Esempio inserimento dati</title>
</head>
<body>
<form action=“insert.php” method=“post”>
Username: <input name=“user” type=“text”/>
Password: <input name=“pass” type=“text”/>
<input type=“submit” value=“Inserisci”>
</form>
</body>
</html>
Il segreto è adesso creare il file insert.php che provvederà ad inserire i dati nella tabella
utenti del database mysql.
<html>
<head>
<title>inserisci dati</</title>
</head>
<body>
<?php
// CONNESSIONE AL DATABASE
// Dichiarazioni variabili per la connessione al database
$host = ‘localhost’;
$user = ‘amokve’;
$password = ”;
$database = ‘my_amokve’;
// Connessione al database server
$connessione= mysql_connect($host, $user, $password)
or die (“impossibile connettersi al server”);
// Selezione del database
mysql_select_db($database)
or die (“impossibile connettersi al database $database”);
// INSERISCO I NUOVI DATI
// lancio la query
$risultato_insert = mysql_query($query_insert);
// controllo l’esito
if (!$risultato_insert) {
die(“Errore nella query $query_insert: “ . mysql_error());
}
$user= $_POST[‘user’];
$pass= $_POST[‘pass’];
Abbiamo creato due variabili. Importante è l’istruzione in php $_POST serve per
richiamare le istruzioni inserite nei campi: user e pass.
$risultato_insert = mysql_query($query_insert);
if (!$risultato_insert) {
die(“Errore nella query $query_insert: “ . mysql_error());
}
Viene effettuato un controllo della query. Da notare il punto esclamativo iniziale “!” che
in php ha un significato di negazione. Tutto va tradotto in questo modo:
se (if) risultano della query (racchiuso nella variabile $risultato_insert) non manifesta
esito negativo (!) allora tutti i dati inseriti nel form saranno processati ed inseriti nei
campi del database. In caso contrario non si procederà all’inserimento dei dati. Al
termine del controllo la connessione al database verrà chiusa ( Mysql_close) e apparirà a
video un messaggio di corretto inserimento delle istruzioni.
Figura 19: il dato inserito attraverso il form insert.html corrispondente al record con
IdUtente 7
LEZIONE 6
$GET - $POST – UPDATE – DELETE FROM
$user= $_POST[‘user’];
$pass= $_POST[‘pass’];
Abbiamo creato due variabili. Importante è l’istruzione in php $_POST serve per
richiamare le istruzioni inserite nei campi: user e pass (file insert.php)
Nei listati della lezione N.5 abbiamo utilizzato il metodo POST (in altro riprendiamo le
parti del codice) per passare i dati dal form html al file insert.php
Un metodo diverso per passare i dati dal form html al file php è l’istruzione: GET
Il funzionamento è analogo al metodo POST.
A tale scopo eseguiamo un esercizio creando due nuovi file in HTML:
<html>
<head>
<title>Esempio inserimento dati</title>
</head>
<body>
<form action=“get.php” method=“get”>
Nome: <input name=“nome” type=“text”/>
<input type=“submit” value=“Inserisci”>
</form>
</body>
</html>
Salviamo il form con il nome get.html e trasferiamolo all’interno del server di Altervista.
<html>
<head>
<title>Esempio inserimento dati</title>
</head>
<body>
<form action=“post.php” method=“post”>
Nome: <input name=“nome” type=“text”/>
<input type=“submit” value=“Inserisci”>
</form>
</body>
</html>
Salviamo il form con il nome post.html e trasferiamolo all’interno del server di Altervista.
Adesso procediamo alla creazione dei due file in php. Uno collegato con il form get.html e
l’altro con il form post.html
<?php
//Recupero il valore del campo nome
$nome_utente = $_GET [‘nome’];
//mostrare a video i dati inseriti
echo “ciao”.$nome_utente;
?>
Con l’istruzione:
echo “ciao”.$nome_utente;
i dati verranno mostrati a video.
<?php
//Recupero il valore del campo nome
$nome_utente = $_POST [‘nome’];
//mostrare a video i dati inseriti
echo “ciao”.$nome_utente;
?>
Questa è l’istruzione in PHP che recupera il valore inserito nel campo nome del modulo
get.html attraverso l’istruzione $_POST [‘nome’] trasferendo il risultato ad una variabile
$nome_utente
Con l’istruzione:
echo “ciao”.$nome_utente;
i dati verranno mostrati a video.
Proviamo il nostro lavoro puntando il nostro browser sul file get.html ed inseriamo un
nome a piacere:
Figura 20: inseriamo un nome nel modulo get.html
Con il metodo GET è importante notare la parte finale dell’indirizzo url (parte selezionata
nell’immagine 21) “?nome=Mario” dove viene mostrato il dato inserito nel campo
all’interno dell’indirizzo della pagina web. Per questo motivo molti programmatori (e
forse non a torto) ritengono il metodo GET meno sicuro rispetto ad altri metodi di
richiamo delle informazioni, come il metodo POST.
Infatti con il metodo POST questi problemi (dato mostrato nell’indirizzo url della pagina
web) non esistono e l’indirizzo della pagina appare più pulito. Puntiamo il browser sul file
post.html ed inseriamo lo stesso nome. Otterremo un risultato uguale ma l’indirizzo url ci
appare più sicuro.
<?php
////////////////////////////////////////////////////////////////////////
//// CONNESSIONE AL DATABASE
////
////////////////////////////////////////////////////////////////////////
//Dichiarazioni variabili per la connessione al database
$host = ‘localhost’;
$user = ‘amokve’;
$password = ”;
$database = ‘my_amokve’;
// Connessione al database server
$connessione= mysql_connect($host, $user, $password)
or die (“impossibile connettersi al server”);
// Selezione del database
mysql_select_db($database)
or die (“impossibile connettersi al database $database”);
////////////////////////////////////////////////////////////////////////
//// MODIFICO I DATI
////
////////////////////////////////////////////////////////////////////////
// script per la modifica dei dati nella tabella
//
$dati = mysql_query (“UPDATE utenti SET User=‘Davide’ WHERE IdUtente=‘7’”);
// fine script ?>
//Dichiarazioni variabili per la connessione al database
$host = ‘localhost’;
$user = ‘amokve’;
$password = ”;
$database = ‘my_amokve’
Dichiarazione variabili per la connessione al database di cui abbiamo ampiamente
parlato in precedenza. Basta solo ricordare di sostituire i propri dati relativi alla variabile
$user e $database per la connessione al vostro database mysql.
Ricordiamo che il campo IdUtente è stato impostato come chiave primaria che si
incrementa in automatico. Questo significa che la numerazione è attribuita dal sistema e
non inserita manualmente da noi come per gli altri dati. L’aspetto importante della chiave
primaria numerica è che non ammette duplicati, conteggia sempre in avanti, per cui se
elimino alcuni record della tabella, non verranno più riproposti. Ed in effetti nel nostro
caso i record 5 e 6 sono stati eliminati e l’inserimento del record successivo inizia con
IdUtente=7.
Procediamo con il nostro esperimento:
Salviamo il file precedente con il nome modifica.php e trasferiamo l’oggetto nel server di
Altervista.
Premettiamo che questa esercitazione sarà raffinata nelle lezioni successive. Qui invece ci
interessa solo capire il funzionamento dell’istruzione UPDATE.
Puntiamo il browser sul file appena caricato all’interno dello spazio hosting e premiamo
invio. Non visualizzeremo niente all’interno della pagina web, anche se è possibile
inserire un’istruzione “echo” per mostrare un messaggio di avvenuta elaborazione, il file
modifica.php eseguirà la query UPDATE, modificando il dato “User” in corrispondenza
del valore IdUtente=7.
Tornando nella tabella utenti noteremo in corrispondenza di IdUtenti=7:
User=Davide e Password=Venditti
DELETE FROM
Passiamo adesso ad illustrare l’istruzione DELETE FROM che serve per eliminare i dati
contenuti nella tabella del database.
Il codice è praticamente uguale a quello già scritto per l’istruzione UPDATE. Cambia solo
la parte finale:
<?php
////////////////////////////////////////////////////////////////////////
//// CONNESSIONE AL DATABASE
////
////////////////////////////////////////////////////////////////////////
//Dichiarazioni variabili per la connessione al database
$host = ‘localhost’;
$user = ‘amokve’;
$password = ”;
$database = ‘my_amokve’;
// Connessione al database server
$connessione= mysql_connect($host, $user, $password)
or die (“impossibile connettersi al server”);
// Selezione del database
mysql_select_db($database)
or die (“impossibile connettersi al database $database”);
////////////////////////////////////////////////////////////////////////
//// ELIMINO I DATI
////
////////////////////////////////////////////////////////////////////////
// script eliminazione dei dati nella tabella
//
$dati = mysql_query (“DELETE FROM utenti WHERE IdUtente=‘7’”);
// fine script ?>
LEZIONE 7
Esercitazione: Lettura dati Tabella, modifica, cancellazione e
inserimento dati
<?php
//Dichiarazioni variabili per la connessione al database
$host = ‘localhost’;
$user = ‘amokve’;
$password = ”;
$database = ‘my_amokve’;
// Connessione al database server
$connessione= mysql_connect($host, $user, $password) or die (“impossibile
connettersi al server”);
// Selezione del database
mysql_select_db($database) or die (“impossibile connettersi al database
$database”);
?>
Il listato successivo serve per leggere e dunque visualizzare i dati contenuti nella tabella
del database. Abbiamo già incontrato questa caratteristica con il file leggitutto.php, adesso
però i risultati verranno presentati in modo più ordinato in un nuovo file che chiameremo
visualizza.php
<?php
/*
VIEW.PHP
Visualizza tutti i dati della tabella ‘utenti’
*/
// connessione al database
include(‘connect-db.php’);
// chiude la tabella>
echo “</table>”;
?>
// chiude la tabella>
echo “</table>”;
Creazione della tabella che verrà mostrata nella pagina web con i dati della query
precedente.
Il ciclo While serve per leggere i dati della tabella del database attraverso l’istruzione
mysql_fetch_array racchiudendo il tutto in una variabile $row.
Le istruzioni successive stampano a video il risultato dei record della tabella del database
riprodotte in una tabella html.
A questo punto la nostra interfaccia web per la gestione del database è pronta, ci occorre
solo creare i file edit.php, delete.php (indicati come link nel listato della tabella) e in
seguito il file insert.php per l’inserimento delle informazioni. Si tratterà comunque di
apportare modifiche più dettagliate ai file che abbiamo illustrato nelle lezioni precedenti.
Se puntiamo il browser sul file visualizza.php tutti i dati della tabella verranno mostrati
come nella figura successiva in una pagina web.
Figura 24: Dati all’interno della tabella “utenti” mostrati nella pagina web
<?php
// CONNESSIONE AL DATABASE
include(‘connect-db.php’);
$id=$_GET[‘id’]; // RECUPERA VARIABILE ID DA PAGINA PRECEDENTE
$rs = mysql_query(“SELECT * FROM utenti WHERE IdUtente=’$id’”); // QUERY
SQL
$row = mysql_fetch_array($rs); // DEFINISCE VARIABILE $row
?>
<?php
// CREA CODICE HTML
?>
Commentiamo il codice
// CONNESSIONE AL DATABASE
include(‘connect-db.php’);
Gestione della connessione al database
A questo punto creiamo un codice in html dove verranno richiamati tutti i dati
corrispondenti all’ID da modificare:
<?php
// CONNESSIONE AL DATABASE
include(‘connect-db.php’);
// RECUPERA DATI DAL FORM E AGGIORNA
$id=$_POST[‘id’];
$user=$_POST[‘user’];
$password = $_POST[‘password’];
header(“Location: visualizza.php”);
?>
// CONNESSIONE AL DATABASE
include(‘connect-db.php’);
Stabiliamo la connessione con il database
mysql_close();
chiudiamo la connessione al database
header(“Location: visualizza.php”);
Istruzione che ci indirizza in automatico al file visualizza.php
Dopo aver trasferito tutti i file all’interno del server di Altervista possiamo eseguire le
nostre prove.
Apriamo nuovamente con il nostro Browser il file visualizza.php e proviamo a cliccare sul
link modifica corrispondente al primo record (Mario Rossi):
<?php
// CONNESSIONE AL DATABASE
include(‘connect-db.php’);
$id=$_GET[‘id’];
header(“Location: visualizza.php”);
?>
Commentiamo il codice:
include(‘connect-db.php’);
Gestione della connessione al database mysql
$id=$_GET[‘id’];
Richiamiamo in questo modo le informazioni corrispondenti al record che ci interessa
cancellare
mysql_query (“DELETE FROM utenti WHERE IdUtente=’$id’”)
or die(mysql_error());
mysql_close();
Query di cancellazione (con gestione degli errori e chiusura della connessione al
database) del record corrispondente all’Id richiamato. Si legge:
Cancella dalla tabella utenti il dato IdUtente (ricordiamo che è un numero impostato
come chiave primaria) dove il numero IdUtente è uguale al record scelto.
<?php
/*
VIEW.PHP
Visualizza tutti i dati della tabella ‘utenti’
*/
// connessione al database
include(‘connect-db.php’);
// chiude la tabella>
echo “</table>”;
?>
<p><a href=“insert.html”>Aggiungi un nuovo record</a></p>
Insert.php
<html>
<head>
<title>inserisci dati</</title>
</head>
<body>
<?php
// CONNESSIONE AL DATABASE
// Dichiarazioni variabili per la connessione al database
$host = ‘localhost’;
$user = ‘amokve’;
$password = ”;
$database = ‘my_amokve’;
// Connessione al database server
$connessione= mysql_connect($host, $user, $password)
or die (“impossibile connettersi al server”);
// Selezione del database
mysql_select_db($database)
or die (“impossibile connettersi al database $database”);
// INSERISCO I NUOVI DATI
// lancio la query
$risultato_insert = mysql_query($query_insert);
// controllo l’esito
if (!$risultato_insert) {
die(“Errore nella query $query_insert: “ . mysql_error());
}
</body>
</html>
LEZIONE 8
Session – Realizzare una semplice area riservata con PHP e
MySqL
In questa lezione torneremo alle origini della prima parte del libro, quando abbiamo
realizzato come esempio iniziale, una semplicissima area riservata gestita con un file php.
Adesso invece sviluppiamo l’esercitazione con un collegamento al database MySqL.
Riutilizzeremo a tale scopo il codice già incontrato nelle precedenti lezioni con le
opportune modifiche del caso:
connect-db.php (per la gestione della connessione al database)
insert.html (Form di inserimento dei dati)
insert.php (file per inviare i dati all’interno della tabella utenti)
Il nostro scopo è permettere agli utenti esistenti nella tabella utenti di entrare all’interno di
un’area riservata, essere riconosciuti e quindi visualizzare delle pagine protette nel nostro
server.
Questo nuovo approccio ci introduce a un nuovo concetto che non è stato fino a qui
trattato: Le Sessioni in php
Riprendiamo il file connect-db.php precedente ed aggiungiamo una nuova riga di codice:
<?php
// avvio la sessione
session_start();
//Dichiarazioni variabili per la connessione al database
$host = ‘localhost’;
$user = ‘amokve’;
$password = ”;
$database = ‘my_amokve’;
// Connessione al database server
$connessione= mysql_connect($host, $user, $password) or die (“impossibile
connettersi al server”);
// Selezione del database
mysql_select_db($database) or die (“impossibile connettersi al database
$database”);
?>
session_start();
Come si evince dal listato abbiamo aggiunto una nuova istruzione in PHP. Questo codice
indica l’apertura di una sessione.
Le sessioni sono importanti per la gestione degli utenti che entrano all’interno di un’area
riservata. Stabilisce un momento di dialogo iniziale tra l’utente che è iscritto
all’interno di una tabella del database e il server. L’utente sarà riconosciuto e gli
verrà attribuito un riconoscimento valido per tutta la durata della sua permanenza
nell’area riservata. E’ dunque un elemento di sicurezza ed esclude che pagine protette
possano essere accessibili ad utenti non registrati nella tabella del database.
La sessione è stata strategicamente inserita nel file di connessione al database poiché tutti
gli altri file in php che useremo richiamano connect-db.php tramite l’istruzione include o
require (istruzione analoga che non abbiamo menzionato).
In basso presentiamo il codice riguardante il file login.php, molto importante per la nostra
esercitazione.
<?php
// Includo la connessione al database
require(‘connect-db.php’);
// Se ha trovato un record
if(mysql_num_rows($query) == 1)
{
// prelevo l’id dal database
$login = mysql_fetch_array($query);
// reindirizzo l’utente
header(‘Location: privata.php’);
exit;
}
// se non esiste da l’errore
else
die(‘Nome Utente o Password errati’);
}
?>
<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0 Transitional//EN”
“http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd”>
<html xmlns=“http://www.w3.org/1999/xhtml”>
<head>
<meta http-equiv=“Content-Type” content=“text/html; charset=utf-8” />
<title>Login</title>
</head>
<body>
<form action=”” method=“post”>
<input name=“user” type=“text” id=“user” value=“Nome Utente” /><br />
<input name=“pass” type=“password” id=“pass” value=“Password” /><br />
<input name=“login” type=“submit” value=“Login” /><br />
</form>
</body>
</html>
// reindirizzo l’utente
header(‘Location: privata.php’);
exit;
}
Se tutte le condizioni sono verificate l’utente (riconosciuto perché presente nella tabella
del database) sarà reindirizzato ad una pagina privata.php
Descriviamo adesso il listato della pagina “privata.php” a cui l’utente viene indirizzato se
riconosciuto dal sistema in fase di login.
<?php
// Includo la connessione al database
require(‘connect-db.php’);
<body>
Pagina privata!<br />
<br />
<br />
<?php
// recupera i dati della sessione
Commentiamo il codice:
if(!isset($_SESSION[‘login’]))
{
header(‘Location: index.php’);
exit;
}
Se la sessione di login non è nulla (!isset) allora si viene reindirizzati alla pagina
index.php
<body>
Pagina privata!<br />
<br />
<br />
<?php
// recupera i dati della sessione
<body>
Menu:<br />
<br />
<br />
<?php
if(isset($_SESSION[‘login’]))
echo ‘<a href=“privata.php”>Area privata</a><br /><a
href=“logout.php”>Logout</a><br />’;
else
echo ‘<a href=“insert.html”>Aggiungi Utente</a><br /><a
href=“login.php”>Login</a><br />’;
?>
</body>
</html>
Questa pagina contiene un menu che può aiutare l’utente a gestire la connessione. È
dunque una pagina di supporto.
<body>
Logout eseguito<br />
<a href=“index.php”>Vai all’index</a><br />
</body>
</html>
session_destroy();
è importante questa istruzione perché chiude la sessione dell’utente quando esce
dall’area riservata
Figura 28: Puntiamo sul file login.php – come si nota dall’indirizzo url della pagina tutti i
file dell’esercitazione descritti in questa lezione sono stati inseriti in una cartella
“area_riservata” che è stata trasferita nel server
Se proviamo ad inserire un Nome Utente e una Password non comprese nel database il
sistema genererà un risultato di errore.
Figura 29: Abbiamo inserito un Nome Utente e Password compresi nella tabella del
database. Il sistema riconosce l’utente (es. mario rossi) e lo indirizza nella pagina riservata
“privata.php”
Figura 30: il menu della pagina index.php – possiamo considerarla anche come pagina di
partenza nella gestione della nostra area riservata.
Gentile Utente, Ti ringraziamo per aver effettuato il Download del libro elettronico dedicato alla
programmazione PHP+MySqL
E’ possibile utilizzare il Coupon seguente per ottenere uno sconto del
– 25% su tutti i prodotti che troverai nel portale di:
www.corsi-online.it
Scegli il tuo corso o la tua guida preferita (video o ebook) e segui le informazioni riportate
successivamente:
1) Scegli il tuo prodotto preferito e procedi all’acquisto
2) Aggiungi il prodotto al carrello e vai al carrello
3) Procedi ad inserire il coupon sottostante e clicca “Applica codice promozionale”.
4) Effettua il pagamento con PayPal.
apriweb