Logistoris: 2011

Tips
Calendario in PHP e MySQL (da scaricare)	upload+resize+thumbnails di immagini (link diretto)
Gestione delle news (link diretto) - KandalfNews Gestione delle news (link diretto) - DMA_News (con immagini e html)	Stringhe di testo (link diretto)
Upload limitato (link diretto)	String manipulation (link diretto)
Date and time in php (link diretto)	Secure login using cookies (link diretto)
Leggere e scrivere su un file in php (link diretto)	Utilizzo di MySQL (link diretto)
Creare un contatore di accessi con Php e Mysql (link diretto)	Install mySQL , php, & Apache in Windows (link diretto)
Random Images (link diretto)	Random Number (link diretto)
Autenticare gli utenti con PHP + Creating a Login Script with PHP and MySQ	VideoCOpen (Videocopen software video conferenza)
	File Manager
Recupero password di root in mysql	Formattazione di un paragrafo in stile giustificato
Script per l'upload dei files via browser	Impostare data in formato standard europeo ovvero gg-mm-aaaa
MySQL Field Types - Campi in MySQL	Connessione a MySQL con PHP
PHP e funzione mail()	Effettuare il redirect con Php
Reading a File Using PHP - Leggere un file utilizzando PHP	Append a String to a File Using PHP
Reading a Remote File Using PHP	List a Directory's Contents Using PHP
Uploading Files To the Server Using PHP	Paging using PHP
Tabelle orizzontali e verticali	Javascript effects within PHP (2 examples here, rollover and popup)
Controllo della compilazione dei campi - Verificare la corretta compilazione di un Form	Array di files all'interno di una stessa pagina
Protezione dei file su server APACHE	Suddividere il contenuto di un testo su piu pagine - Suddividere dinamicamente un testo su più pagine - Dividere il testo dopo tot parole senza spezzare la frase
Creare un database di testo in PHP	Realizzare contatore per i click
Cambio immagine a ogni aggiornamento di pagina	Data e Ora
Indirizzo Ip	Nome pagina corrente
Browser Internet	Linguaggio Browser
Nome Host	Ultimo Aggiornamento
E' possibile evitare che gli utenti del mio sito inseriscano caratteri dannosi attraverso i miei form?	Upload dei file
Creare un guestbook	Realizzare un sondaggio
Eseguire l'upload di un file	Gestione dei file in PHP
Un sistema di login con le sessioni	Evitare la ridondanza dei dati in un database
Creare un guestbook	Realizzare un sondaggio
Eseguire l'upload di un file	Gestione dei file in PHP
Realizzare un semplice contatore	Configurare php per l'invio di e-mail in locale
Aggiornare automaticamente il copyright all'anno attuale	Il modulo Segnala ad un amico
Operazioni sulle stringhe con Php	Generare password casuali
Variabili php	Inserire data e ora in una pagina web
Recuperare la dimensione di un file	Realizzare un sito facilmente aggiornabile
Creare un RSS con PHP e MySql	Visualizzare un'immagine... solo se il campo di un database non è vuoto
Invio e-mail	Creare un circuito banners in PHP
Creiamo un Photoblog con PHP e MySQL	Applicazione in Php per gestire facilmente una newsletter
Utilizzare PHP con MySQL	Creare un circuito banners in PHP
Un completo AdServer con PHP	Scrivere i file con i form
Come fare un sondaggio con php e mysql	Ricavare IP & Hostname con Php
Motore di ricerca con PHP	Mostrare il numero degli utenti collegati al nostro sito
Grafici in HTML con PHP	Come fare un sondaggio
Rotazione BANNER + Un circuito di rotazione banner in Php	Paginazione dei dati presenti in un file di testo senza uso di database
Realizziamo una feedback form	Mandare un mail in CC o BBC
Scrivere il contenuto di una variabili in un file	Trasferire un file tramite FTP
Estensioni in php	Banner Rotating System with PHP
Leggere e scrivere su file	Come ottimizzare le tabelle di un database MySQL
Gestiamo i database con PhpMyAdmin	Immagine non disponibile
Proteggere una pagina con username e password	Paginazione dei dati presenti in un file di testo senza uso di database
Usare i cookies con PHP	Gestione Permessi
Gestione Utenti	Gestione di Database
Gestire database, utenti e permessi con MySQL	MySQL: gestione delle tabelle
Stringhe in MySQL: trucchi e soluzioni	Le funzioni stringa
Autenticare gli utenti con PHP	AlberT-menu è una semplice funzione PHP che stampa una tabella di menù
In PHP esiste una funzione tipo lastModified di javascript?	Come posso sapere l‘indirizzo IP di chi stà visitando una pagina PHP?
E' possibile validare i campi di un form attraverso PHP?	Generatore di password casuali
Le Sessioni	Gestire i Cookie
E' possibile convertire una stringa di testo in minuscolo o in maiuscolo?	.Htaccess
Proteggere le pagine senza MySQL	Protezione password
Upload di immagini in un database (1 - 2 - 3 - 4) links diretti	Creare una cartella e uploadare i files con relativa rinomina
Creare un uploader di immagini (link diretto)	Mostrare il numero degli utenti collegati al nostro sito
Scrivere il contenuto di una variabili in un file	Le query SQL
Operatori di ricerca di pattern	Operatori logici
Funzioni logiche e condizionali	Funzioni stringa
Mandare un mail in CC o BBC	Come spedire un' e-mail in formato HTML
Come spedire un' e-mail con PHP	Come ottimizzare le tabelle di un database MySQL
Glossario di errori in PHP	Estrapolare dei dati da un file esterno
PHP: cos'e' e come funziona	Creare un catalogo immagini automatico con PHP
Files dentro a MySQL	Immagini dentro a MySQL
Aggiornare un campo nel DataBase	Contare i campi in un DataBase
Proteggere una pagina con username e password	Ritardare il caricamento di una pagina
Cancellare un record dalla pagina web	Un visualizzatore di immagini in Php
Upload di file in Php	Un contatore di accessi con file di testo
Spedire email con il Php	Connessione ad un database mySql con Php
Un semplice sistema di rotazione banner con PHP e Javascript	Un circuito di rotazione banner in Php
Redirect in Php	Recupero dei dati da un modulo
Scrivere la data e l'ora	Creare un blog in PHP senza bisogno di MySQL
PHP.INI	Form (link diretto)
Creare un guestbook in Php con Dreamweaver MX e MySql (link diretto)	Galleria fotografica (http://www.web-album.org)
Frase del mese	Login sicuro utilizzando i cookies (link diretto)
Data e ora in php (link diretto)	Estensioni di PHP (link diretto)
Come Creare Realizzare Un Sito Dinamico In Linguaggio Php
TIPS PHP2	TIPS PHP3
TIPS PHP4	TIPS PHP5

Tips
Calendario in PHP e MySQL (scarica) oppure dal sito ufficiale: http://www.ikemcg.com/scripts/
                        Calendario simile a Outlook (Agenda): http://www.phenix.gapi.fr/ o scarica qui (forum sul cambio lingua: http://www.phenix.gapi.fr/forum/viewtopic.php?t=206&highlight=langue)
                        WebCalendar: http://www.k5n.us/webcalendar.php - http://www.k5n.us/index.php
                        Php Calendar: http://www.kubelabs.com/phpcalendar/
                       Jax Calendar: http://www.jtr.de/scripting/php/calendar/index.html
File Manager
File Management with PHP (http://www.devshed.com/c/a/PHP/File-Management-with-PHP)
Table of Contents:
# File Management with PHP
# Building the Database
# File_Size() and Display_form Functions
# The Main Program
File Management with PHP
While discussing this problem, other issues arise, such as: Should the program allow the user to restore this file or retain the existing file? If the file exists, then should I copy the file as a new version? How do I manage files, if the user uploads files of same name and type more than once?
Prerequisites
To understand this article, you should have a fair knowledge of PHP. To run examples given in your machine, you need Apache, PHP, and MySQL installed and configured.
Here's what we want to accomplish:
* When a user uploads a file for the first time, the system should upload the file in the specified folder and insert file details (file name, size, and type) in the database table.
* When the user uploads a file for the second time (the filename has to be the same), the system will compare the size, date and time of the existing file and of the file being uploaded, and automatically assign a new version for the uploaded file if there is a difference. If there is no difference, then the existing file will be retained and a message will be displayed for the user.
* A check box allows the user to replace the existing file. Clicking this option will replace the existing file. Note that only the latest version of the file can be replaced in this case, and not an older one.
* The database will maintain file list and version details. Users should be able to view all the versions of a file and download the required version.
* While displaying the file list, the program displays all the versions of files under one name. For example, if the file name is xyz.doc and its other versions are xyz_VERSION1.doc, xyz_VERSION2.doc, xyz_VERSION3.doc, and so on, the program will display the filename as xyz.doc for all the versions.
* The program allows users to delete the file. Clicking on delete will ask for confirmation before proceeding.

Name the database "upload". The database contains the table 'file_manager', which manages file information. The SQL statement for creating the table:
CREATE TABLE file_manager
(
file_name varchar(50) default NULL,
file_type varchar(20) NOT NULL default '',
file_size varchar(20) NOT NULL default '',
file_modified varchar(20) NOT NULL default '',
file_parent_id mediumint(9) default NULL,
file_image_name varchar(50) default NULL,
KEY file_name (file_name),
KEY file_image_name (file_image_name)
)
TYPE=MyISAM;
File Management
I've written two programs to manage this file version. The first uploads the file (file_upload_manager.php), the second displays the file (file_upload_manager.php). The source code is tested on a Windows system.
NOTE: Linux users, please change the folder path accordingly.
File Upload Manager:
This program displays a menu to select the file in your system, a check box and an Upload button. Once the user clicks the upload button, the program checks the file for existence, and undergoes a series of tests as described in the plan.
Now let's look at the code snippets used in the program.
$dir_path Variable
:
This variable is the destination folder path.
$dir_path
= "C:apachehtdocsfilemanager";
This path is given for Windows-based systems. Please change your destination folder accordingly.
Get_New_File_Name
() Function:
This function is called from the main program when the program encounters files that exist and show a difference in size, date or time. This function will generate a new file name and return to the main function.
function Get_New_FIle_Name
($file_name)
{
$sqlQuery="SELECT file_image_name FROM file_manager WHERE file_name
LIKE '$file_name%' AND file_parent_id=1";
$fResult=mysql_query($sqlQuery);
$Last_Version=0;
$ver=0;
if(mysql_num_rows($fResult)){
while($fRow=mysql_fetch_array($fResult)){
list($junk,$ver)=explode("_VERSION",$fRow['file_image_name']);
list($ver,$extn)=explode(".",$ver);
$Last_Version = $Last_Version > $ver ? $Last_Version :
$ver;
}
}else{
$new_file_name
=$file_name."_VERSION".++$Last_Version;
return
$new_file_name;
}
if($Last_Version !=0){
$new_file_name=$file_name."_VERSION".++$Last_Version;
return $new_file_name;
}
}
The sql query in the beginning of the function will fetch file names of previous versions. If the sql query returns record sets, it means the file has previous versions. The while loop is executed to store the generated version number, and the value obtained is stored in $Last_Version. Otherwise, the new file name will be generated as file-name_VERSION1.
The next if statement checks for $Last_Version != 0, if true, $Last_Version is incremented by 1 and a new file name is assigned.
The return statement will return a new file name generated to the called statement.

File_Size() Function:
This function returns the file size in terms of Bytes, Kb or Mb.
<?
function
File_Size($size)
{
if($size >
104876){
return
$return_size=sprintf("%01.2f",$size / 1048576)."

Mb";
}elseif($size >
1024){
return
$return_size=sprintf("%01.2f",$size / 1024)." Kb";

}else{
return $return_size=$size."
Bytes";
}
}
? >
Display_form() Function:
This function is used to prompt the user to select the file from your local machine.
<?
function display_form($errMsg){
global $dir_path; ? >
<html>
<head><title>File
Manager</title></head>
<body bgcolor="#E5E5E5">
<div
align="center">
<h4>File Manager</h4>
<? if($errMsg){
? ><font face="verdana, helvetica" size="2"
color="red"><? echo $errMsg ? ></font>
<?
}
?
>
<form action="<? echo $PHP_SELF; ? >"
enctype="multipart/form-data"
method="POST">
<table border="1">
<tr><th>File
Location:</th><th><input type="file" name="up_file"
/></th></tr>
<tr><th
colspan="2"><br><input type="checkbox" name="replace"
value="1">Replace Exiting File*</th></tr>
<tr><th
colspan="2"><br><input type="submit" name="upload" value="Upload
File !" /></th></tr>
</table>
<br>* - Clicking this option will replace the existing
file
<br><a href="file_display_manager.php">File
Manager</a>
<br><? if ($status){ echo "Result :".$status; }?
>
<p><br><b>Folder Location:</b><? echo $dir_path ?
>
<br>You can change this location by editing the
file</font>
</form>
</div>
</body>
</html>
<? } ? >

When you execute file_upload_manager.php, the code is executed first and the other functions described above are called in the middle of the program. Once the user selects the file and clicks upload, the main program part is executed. Here the program gets the upload file information like file size, file type, date modified and time stamp. Next it checks for the file existence in the destination folder. If the file is present the "if" part of the program gets executed, otherwise the file is copied to the destination folder and the file information is inserted in the database. If the file exists, and if the file size and/or time stamp differs, Get_New_File_Name() function is called to generate a new file name. Then the file is copied to the destination folder and the file information is stored in the database. If the file exists and the user had checked the "Replace Existing File" option, the file is replaced and the file information is updated in the database accordingly.
Otherwise, the user is redirected to the file_display_manager.php page and the message "A previous version of this file exists" is displayed.
File Display Manager:
This PHP script handles the displaying of files present in the folder. As described in the plan, the program will display the file name, size, type and an option to delete the file.
dir_display
() Function:
This function displays the files available in the folder in a table. The template looks like this:
File Manager

	Size	Type	Modified
abc.doc	25 Kb	doc	Oct 01, 2003	Delete
xyz.txt	24 bytes	txt	Oct 03, 2003	Delete
abc.doc	48 Kb	doc	Oct 05, 2003	Delete
abc.doc	67 Kb	doc	Nov 05, 2003	Delete
xyz.txt	58 bytes	txt	Oct 23, 2003	Delete

You can see that the file names are repeated, but you can see the file size and date modified differs. To view and/or download the file, you can click the hyperlink of the file name. This will show you the file name of the different version. You can customize the program to include another field "Version" to track the file version.
To delete a file, click on the 'Delete' hyperlink, which will prompt for confirmation.

Recupero password di root in MySql
Se non avete mai impostato la password,cioè nella prima installazione, allora non è necessario inserirla, ma se la aveste impostata e poi dimenticata....allora seguite le seguenti istruzioni:
Per Mysql sotto windows:
* Entrare come amministratore...o comunque come utente avete i permessi adeguati per eseguire i seguenti passi.
* Fermare il server Mysql se è attivo, andando nella gestione dei servizi:
Start Menu -> Control Panel -> Administrative Tools -> Services
Trovare la voce relativa al servizio Mysql e fermatelo.(se il server fosse attivo come processo e non come servizio usate il Task Manager)
* Create un file di testo e inseriteci la seguente riga:
SET PASSWORD FOR 'root'@'localhost' = PASSWORD('NuovaPassword');
Salvate il file, ad esempio c:\mysql-init.txt
* Aprite una console Dos :
Start Menu -> Esegui -> cmd
Come esempio immaginiamo che il server sia installato nella directory c:\mysql ,se cosi nn fosse, fate le dovute modifiche.
* Al prompt del DOS scrivete il seguente comando :
C:\> C:\mysql\bin\mysqld-nt --init-file=C:\mysql-init.txt
In pratica in questo modo verrà eseguita una serie di comando allo startup del server mysql...che in qiesto caso modificherà la password di root.
* Fermate di nuovo il server e riavviatelo...ora come login per l'utente "root" dovrete usare la password che avete impostato voi...in questo caso sarà "NuovaPassword".
Per linux:
Seguono le istruzioni per resettare una password di root di mysql:
# stoppare mysqld
#killall mysqld
# lanciare mysqld con l'opzione skip-grant-tables, che evita di caricare le tabelle di sistema (tra cui anche quella degli accessi) fornendo libero accesso al servizio mysqld
# /usr/libexec/mysqld -Sg --user=root &
/usr/libexec/mysqld: ready for connections
# entrare in modalità client
# mysql
Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 1 to server version: 3.23.56
Type 'help;' or '\h' for help. Type '\c' to clear the buffer.
#collegarsi al db mysql e inserire la query di update di cambio password
mysql> USE mysql
Reading table information for completion of table and column names
You can turn off this feature to get a quicker startup with -A
Database changed
mysql> UPDATE user
-> SET password=password("mianuovapassword")
-> WHERE user="root";
Query OK, 2 rows affected (0.00 sec)
Rows matched: 2 Changed: 2 Warnings: 0
mysql> flush privileges;
Query OK, 0 rows affected (0.00 sec)
mysql> exit
Per eventuali problemi ed approfondimenti il problema è documentato nel sito di mysql a questo indirizzo : http://dev.mysql.com/doc/refman/5.0/en/resetting-permissions.html
PHP: formattazione di un paragrafo in stile giustificato
Il trucco che vi presentiamo riguarda la formattazione di un paragrafo in stile giustificato con l'utilizzo del linguaggio PHP, per la creazione di pagine dinamiche.
Esiste, tra le parole riservate del linguaggio PHP, echo(...).
Dove sono indicati i tre punti di sospensione dovrete indicare, tra doppi apici, una stringa.
La stringa a riguardo sarà proprio una riga sintatticamente corretta di un tag html, ossia il tag P..
In HTML per giustificare un paragrafo scriverete:
<p align="justify">blocco di testo</p>
Nel linguaggio PHP invece:
<?php
echo("<p align='justify'>blocco di testo di più righe</p>");
?>
Siccome l'argomento da passare alla parola riservata echo viene racchiuso tra doppi apici, quando settate l'attributo align userete gli apici singoli.
Script per l'upload dei files via browser
Di seguito riportiamo un esempio basico di script per l’upload di file via browser
 
<?
/********************* VARIABILI DA SETTARE ********************/
// Directory dove salvare i files Uploadati ( chmod 777 o permessi di scrittura, percorso assoluto)
$upload_dir = $_SERVER["DOCUMENT_ROOT"] . "/upload";
// Eventuale nuovo nome da dare al file uploadato
$new_name = "";
// Se $new_name è vuota, il nome sarà lo stesso del file uploadato
$file_name = ($new_name) ? $new_name : $_FILES["upfile"]["name"];
if(trim($_FILES["upfile"]["name"]) == "") {
die("Non hai indicato il file da uploadare !");
}
if(@is_uploaded_file($_FILES["upfile"]["tmp_name"])) {
@move_uploaded_file($_FILES["upfile"]["tmp_name"], "$upload_dir/$file_name")
or die("Impossibile spostare il file, controlla l'esistenza o i permessi della directory dove fare l'upload.");
} else {
die("Problemi nell'upload del file " . $_FILES["upfile"]["name"]);
}
echo "L'upload del file " . $_FILES["upfile"]["name"] . " è avvenuto correttamente";
?>Impostare data in formato standard europeo ovvero gg-mm-aaaa
Con una query sql si può riportare una data specifica oppure, con la funzione now() al posto della data, inserire la data corrente
1) impostare il campo dove inserire la data come stringa;
2) INSERT INTO tabella('campo') VALUES (DATE_FORMAT('2009-10-04 22:23:00', '%d-%m-%Y'))
Per ulteriori informazioni si consulti http://dev.mysql.com/doc/refman/5.1/en/date-and-time-functions.html#function_date-format
MySQL Field Types - Campi in MySQL
(http://help.scibit.com/Mascon/masconMySQL_Field_Types.html)
MySQL supports a number of column types, which may be grouped into three categories: numeric types, date and time types, and string (character) types. This section first gives an overview of the types available. Please refer to the MySQL manuals for more details.

Type	Use for	Size
TINYINT	A very small integer	The signed range is –128 to 127. The unsigned range is 0 to 255.
SMALLINT	A small integer	The signed range is –32768 to 32767. The unsigned range is 0 to 65535
MEDIUMINT	A medium-size integer	The signed range is –8388608 to 8388607. The unsigned range is 0 to 16777215
INT or INTEGER	A normal-size integer	The signed range is –2147483648 to 2147483647. The unsigned range is 0 to 4294967295
BIGINT	A large integer	The signed range is –9223372036854775808 to 9223372036854775807. The unsigned range is 0 to 18446744073709551615
FLOAT	A small (single-precision) floating-point number. Cannot be unsigned	Ranges are –3.402823466E+38 to –1.175494351E-38, 0 and 1.175494351E-38 to 3.402823466E+38. If the number of Decimals is not set or <= 24 it is a single-precision floating point number
DOUBLE, DOUBLE PRECISION, REAL	A normal-size (double-precision) floating-point number. Cannot be unsigned	Ranges are -1.7976931348623157E+308 to -2.2250738585072014E-308, 0 and 2.2250738585072014E-308 to 1.7976931348623157E+308. If the number of Decimals is not set or 25 <= Decimals <= 53 stands for a double-precision floating point number
DECIMAL, NUMERIC	An unpacked floating-point number. Cannot be unsigned	Behaves like a CHAR column: “unpacked” means the number is stored as a string, using one character for each digit of the value. The decimal point, and, for negative numbers, the ‘-‘ sign is not counted in Length. If Decimals is 0, values will have no decimal point or fractional part. The maximum range of DECIMAL values is the same as for DOUBLE, but the actual range for a given DECIMAL column may be constrained by the choice of Length and Decimals. If Decimals is left out it’s set to 0. If Length is left out it’s set to 10. Note that in MySQL 3.22 the Length includes the sign and the decimal point
DATE	A date	The supported range is ‘1000-01-01’ to ‘9999-12-31’. MySQL displays DATE values in ‘YYYY-MM-DD’ format
DATETIME	A date and time combination	The supported range is ‘1000-01-01 00:00:00’ to ‘9999-12-31 23:59:59’. MySQL displays DATETIME values in ‘YYYY-MM-DD HH:MM:SS’ format
TIMESTAMP	A timestamp	The range is ‘1970-01-01 00:00:00’ to sometime in the year 2037. MySQL displays TIMESTAMP values in YYYYMMDDHHMMSS, YYMMDDHHMMSS, YYYYMMDD or YYMMDD format, depending on whether M is 14 (or missing), 12, 8 or 6, but allows you to assign values to TIMESTAMP columns using either strings or numbers. A TIMESTAMP column is useful for recording the date and time of an INSERT or UPDATE operation because it is automatically set to the date and time of the most recent operation if you don’t give it a value yourself
TIME	A time	The range is ‘-838:59:59’ to ‘838:59:59’. MySQL displays TIME values in ‘HH:MM:SS’ format, but allows you to assign values to TIME columns using either strings or numbers
YEAR	A year in 2- or 4- digit formats (default is 4-digit)	The allowable values are 1901 to 2155, and 0000 in the 4 year format and 1970-2069 if you use the 2 digit format (70-69). MySQL displays YEAR values in YYYY format, but allows you to assign values to YEAR columns using either strings or numbers. (The YEAR type is new in MySQL 3.22.)
CHAR	A fixed-length string that is always right-padded with spaces to the specified length when stored	The range of Length is 1 to 255 characters. Trailing spaces are removed when the value is retrieved. CHAR values are sorted and compared in case-insensitive fashion according to the default character set unless the BINARY keyword is given
VARCHAR	A variable-length string. Note: Trailing spaces are removed when the value is stored (this differs from the ANSI SQL specification)	The range of Length is 1 to 255 characters. VARCHAR values are sorted and compared in case-insensitive fashion unless the BINARY keyword is given
TINYBLOB, TINYTEXT		A BLOB or TEXT column with a maximum length of 255 (2^8 - 1) characters
BLOB, TEXT		A BLOB or TEXT column with a maximum length of 65535 (2^16 - 1) characters
MEDIUMBLOB, MEDIUMTEXT		A BLOB or TEXT column with a maximum length of 16777215 (2^24 - 1) characters
LONGBLOB, LONGTEXT		A BLOB or TEXT column with a maximum length of 4294967295 (2^32 - 1) characters
ENUM	An enumeration	A string object that can have only one value, chosen from the list of values ‘value1’, ‘value2’, ..., or NULL. An ENUM can have a maximum of 65535 distinct values.
SET	A set	A string object that can have zero or more values, each of which must be chosen from the list of values ‘value1’, ‘value2’, ... A SET can have a maximum of 64 members

Connessione a MySQL con PHP
Segue un semplice esempio di codice; assegnare alle variabili iniziali i valori corrispondenti ai propri dati di accesso al servizio, così come comunicato nella mail di attivazione del servizio.
<?
$host= "localhost";
$user= "PROPRIO-USERNAME-MYSQL";
$password= "PASSWORD-MYSQL";
$database= "NOME-DB";
$tabella ="NOME-TABELLA";

mysql_connect($host,$user,$password); //connessione database
mysql_select_db($database) or die("Impossibile selezionare il database");
mysql_query("select * from ". $tabella . "") or die("Impossibile eseguire la query");
mysql_close();
?>
Il codice sopra riportato è un semplice esempio che eseguirà una query al database server e, nel caso in cui l'operazione fallisca, restituirà un messaggio di errore.

PHP e funzione mail()
Per inviare posta attraverso script in php è possibile utilizzare l'apposita funzione di PHP mail() oppure, così come consigliato nella mail di attivazione dei servizi, utilizzare la funzione smtpmail(), sviluppata da MondoServer IT, per inviare posta utilizzando SMTP con autenticazione. La soluzione con autenticazione, di applicazione immediata, è preferibile poichè garantisce elevati livelli di sicurezza al webserver. La funzione smtpmail() viene fornita da MondoServer IT al momento dell'attivazione ed utilizza una sintassi simile a quella della funzione mail(). Segue un esempio di codice per inviare email attraverso PHP, utilizzando la funzione mail():
<?
$to="email@destinatario";
$from="email@mittente";
$subject="Titolo del messaggio";
$messaggio="Rigo 1 del messaggio\n Rigo 2 del messaggio\n Rigo 3 ........";
mail( "$to", "$subject", "$messaggio", "From: $from");
echo "Messaggio inviato a " . $to . ".";
?>
La sintassi della funzione smtpmail() è simile, come si può osservare dal seguente codice:
<?
$to="email@destinatario";
$from="email@mittente";
$subject="Titolo del messaggio";
$user="nome-utente-di-posta";
$password="password-di-posta";
$server="ip-del-server"; //comunicato dal Provider
$messaggio="Rigo 1 del messaggio\n Rigo 2 del messaggio\n Rigo 3 ........";
smtpmail( "$to", "$subject", "$messaggio", "From: $from", $user, $password, $server );
echo "Messaggio inviato a " . $to . ".";
?>

Effettuare il redirect con Php
Per motivi di logistica o di organizzazzione alle volte può essere necessario spostare un file da una posizione sul server ad un' altra. Per evitare di ritrovarsi con collegamenti interrotti e perdita di posizioni nei motori di ricerca si ricorre al redirect (reindirizzamento).
Questo argomento è stato già trattato in precedenza per due linguaggi: Html (Meta-tag) e Javascript.
Supponiamo di disporre della pagina "guestbook.php" inizialmente collocata nella root del sito, e di volerla trasferire nella cartella "guestbook".
Sarà innanzitutto necessario creare la pagina "guestbook/guestbook.php" per il corretto funzionamento del guestbook nella sua nuova posizione sul server, nonchè rimpiazzare il codice di "guestbook.php" (quello nella root) con questo:
<?php
header("Location: guestbook/guestbook.php");
?>
Tanto per spiegarmi meglio avremo due file adesso (e non più uno):
* guestbook.php (che punta al nuovo guestbook grazie al redirect);
* guestbook/guestbook.php (il nuovo guestbook).

Reading a File Using PHP - Leggere un file utilizzando PHP
A simple method for reading a file is to use the file() function which will return an array containing each line of the file. Here's an example :
// open the file and save each line as an array entry in $content
$content = file('myfile.txt');
// count how many lines in the file
$numLines = count($content);
// loop through all the lines
for ($i = 0; $i < $numLines; $i++) {
// each line ends with a newline character
// you may want to get rid of this first
// using trim()
$line = trim($content[$i]);
// do whatever you want to do with that line...
}
The second alternative is using the fopen() and read one line at a time using a while loop like this :
// open the log file and check if the it's opened successfully
if (!($fp = fopen('myfile.txt', 'r'))) {
die('Cannot open file');
}
// keep fetching a line from the file until end of file
while ($line = fgets($fp, 4096)) {
// trim to remove new line character at the end of line
$line = trim($line);

// do whatever you want to do with that line...
}

Append a String to a File Using PHP
To append a string to a file you will need to open the file using fopen() with the 'a' parameter. For example if your log file name is mylog.txt you would write the code like this :
// open the log file and check if the it's opened successfully
if (!($fp = fopen('mylog.txt', 'a'))) {
die('Cannot open log file');
}
// ... your code do something here
// append to log file
// make sure you add a newline character at the end of the log string
fwrite($fp, "Initiate world domination\n");
// ... do some stuff here
// ... and your code do something else here
// append another line to the log file
fwrite($fp, "World domination completed. Bwa ha ha ha...!!");

Reading a Remote File Using PHP
To read a remote file from php you have at least four options :
1. Use fopen()
2. Use file_get_contents()
3. CURL
4. Make your own function using php's socket functions.
First i need to warn you about something. You can only use fopen() and file_get_contents() when fopen wrappers is enabled. This parameter is specified in the php.ini file and cannot be changed at run time using ini_set(), To know whether you can use these two or not you can use the following code to check the value of fopen wrapper seting.
if (ini_get('allow_url_fopen') == '1') {
// use fopen() or file_get_contents()
} else {
// use curl or your custom function
}
1 . Using fopen()
If you use fopen() to read a remote file the process is as simple as reading from a local file. The only difference is that you will specify the URL instead of the file name. Take a look at the example below :
// make sure the remote file is successfully opened before doing anything else
if ($fp = fopen('http://www.google.com/', 'r')) {
$content = '';
// keep reading until there's nothing left
while ($line = fread($fp, 1024)) {
$content .= $line;
}
// do something with the content here
// ...
} else {
// an error occured when trying to open the specified url
}
Now, the code above use fread() function in the while loop to read up to 1024 bytes of data in a single loop. That code can also be written like this :
// make sure the remote file is successfully opened before doing anything else
if ($fp = fopen('http://www.google.com/', 'r')) {
$content = '';
// keep reading until there's nothing left
while ($line = fgets($fp, 1024)) {
$content .= $line;
}
// do something with the content here
// ...
} else {
// an error occured when trying to open the specified url
}
instead of fread() we use fgets() which reads one line of data up to 1024 bytes. The first code is much more preferable than the second though. Just imagine if the remote file's size is 50 kilobytes and consists of 300 lines. Using the first code will cause the loop to be executed about fifty times but using the second the loop will be executed three hundred times.
If you consider the cost to call a function plus the time required to make 300 requests compared to just 5 then clearly the first one is the winner.
2. Using file_get_contents()
This is my favorite way of reading a remote file because it is very simple. Just call this function and specify a url as the parameter. But make sure you remember to check the return value first to determine if it return an error before processing the result
$content = file_get_contents('http://www.google.com/');
if ($content !== false) {
// do something with the content
} else {
// an error happened
}
3. CURL
Unlike the two methods above using CURL cannot be said as straigthforward. Although this library is very useful to connect and communicate with may different protocols ( not just http ) it requires more effort to learn. And another problem is that not all web host have this library in their php installation. So we better make sure to check if the library is installed before trying to use it.
Here is a basic example on fetching a remote file
// make sure curl is installed
if (function_exists('curl_init')) {
// initialize a new curl resource
$ch = curl_init();
// set the url to fetch
curl_setopt($ch, CURLOPT_URL, 'http://www.google.com');
// don't give me the headers just the content
curl_setopt($ch, CURLOPT_HEADER, 0);
// return the value instead of printing the response to browser
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
// use a user agent to mimic a browser
curl_setopt($ch, CURLOPT_USERAGENT, 'Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.7.5) Gecko/20041107 Firefox/1.0');
$content = curl_exec($ch);
// remember to always close the session and free all resources
curl_close($ch);
} else {
// curl library is not installed so we better use something else
}
In some cases using CURL is faster than using file_get_contents() or fopen(). This is because CURL handles compression protocols by default ( for example gzip ). Many sites, big and small, use gzip compression to compress their web pages in order to save bandwidth. This site, for example, also use gzip compression which cut the bandwidth used into half. So if you're the type who just can't wait CURL will fit you most.
4. Custom functions
In the worst case your server will have fopen wrappers disabled and don't have CURL library installed. In this sad situation you just have to make your own way.
Our function shall be named getRemoteFile() which takes only one parameter, the url for the remote file. The skeleton for this function is shown below
function getRemoteFile($url)
{
// 1. get the host name and url path
// 2. connect to the remote server
// 3. send the necessary headers to get the file
// 4. retrieve the response from the remote server
// 5. strip the headers
// 6. return the file content
}
To extract the host name and url path from the given url we'll use parse_url() function. When given a url this function will spit out the followings :
* scheme
* host
* port
* user
* pass
* path
* query
* fragment
For example, if the url is http://www.php-mysql-tutorial.com/somepage.php then parse_url() will return :
Array
(
[scheme] => http
[host] => www.php-mysql-tutorial.com
[path] => /somepage.php
)
and if the url is http://myusername:mypassword@www.php-mysql-tutorial.com/somepage.php?q=whatsthis#ouch then parse_url() will return this :
Array
(
[scheme] => http
[host] => www.php-mysql-tutorial.com
[user] => myusername
[pass] => mypassword
[path] => /somepage.php
[query] => q=whatsthis
[fragment] => ouch
)
For our new function we only care about the host, port, path and query.
To establish a connection to a remote server we use fsockopen(). This function requires five arguments, the hostname, port number, a reference for error number, a reference for the error message and timeout
function getRemoteFile($url)
{
// get the host name and url path
$parsedUrl = parse_url($url);
$host = $parsedUrl['host'];
if (isset($parsedUrl['path'])) {
$path = $parsedUrl['path'];
} else {
// the url is pointing to the host like http://www.mysite.com
$path = '/';
}
if (isset($parsedUrl['query'])) {
$path .= '?' . $parsedUrl['query'];
}
if (isset($parsedUrl['port'])) {
$port = $parsedUrl['port'];
} else {
// most sites use port 80
$port = '80';
}
$timeout = 10;
$response = '';
// connect to the remote server
$fp = @fsockopen($host, '80', $errno, $errstr, $timeout );
if( !$fp ) {
echo "Cannot retrieve $url";
} else {
// send the necessary headers to get the file
fputs($fp, "GET $path HTTP/1.0\r\n" .
"Host: $host\r\n" .
"User-Agent: Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.8.0.3) Gecko/20060426 Firefox/1.5.0.3\r\n" .
"Accept: */*\r\n" .
"Accept-Language: en-us,en;q=0.5\r\n" .
"Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7\r\n" .
"Keep-Alive: 300\r\n" .
"Connection: keep-alive\r\n" .
"Referer: http://$host\r\n\r\n");

// retrieve the response from the remote server
while ( $line = fread( $fp, 4096 ) ) {
$response .= $line;
}
fclose( $fp );
// strip the headers
$pos = strpos($response, "\r\n\r\n");
$response = substr($response, $pos + 4);
}
// return the file content
return $response;
}
The code above sends nine lines of headers but only the first two is mandatory. So even if you send only these
fputs($fp, "GET $path HTTP/1.0\r\n" .
"Host: $host\r\n\r\n");
the function will likely be working correctly. Not always though. Since the file is stored in a remote server It really up to that server to reply to your request or not. Some people code their page to block any request without the proper referer header. Some will only accept a specific user agent. Other will require cookies set in the header.
If you want to see what headers should be sent to successfully fetch a specific remote file try using firefox plus live http headers plugin. It's really a useful little tool

List a Directory's Contents Using PHP
To list the content of a directory you just need to use the combination of opendir() and readdir() functions.
// directory path can be either absolute or relative
$dirPath = '.';
// open the specified directory and check if it's opened successfully
if ($handle = opendir($dirPath)) {
// keep reading the directory entries 'til the end
while (false !== ($file = readdir($handle))) {
// just skip the reference to current and parent directory
if ($file != "." && $file != "..") {
if (is_dir("$dirPath/$file")) {
// found a directory, do something with it?
echo "[$file]<br>";
} else {
// found an ordinary file
echo "$file<br>";
}
}
}
// ALWAYS remember to close what you opened
closedir($handle);
}
When you list the files surely you need to know which of these files are actually a sub-directory. Using the is_dir() function you can test if the files is really a directory or not. What you want to do later with that directory is up to you. On the code above directories are simply printed in a square brackets to differentiate them with ordinary files

Uploading Files To the Server Using PHP
Now, we will make another upload script. But this time we won't save the file in the database. We will only store the file info there but the real file is stored in the file server. We need a little modification to the upload table. Instead of using BLOB datatype we just use VARCHAR to store the file path.
CREATE TABLE upload2 (
id INT NOT NULL AUTO_INCREMENT,
name VARCHAR(30) NOT NULL,
type VARCHAR(30) NOT NULL,
size INT NOT NULL,
path VARCHAR(60) NOT NULL,
PRIMARY KEY(id)
);
The HTML form we use is no different with the previous one since the real changes will take place in the PHP codes.
<form method="post" enctype="multipart/form-data">
<table width="350" border="0" cellpadding="1" cellspacing="1" class="box">
<tr>
<td width="246">
<input type="hidden" name="MAX_FILE_SIZE" value="2000000">
<input name="userfile" type="file" id="userfile">
</td>
<td width="80"><input name="upload" type="submit" class="box" id="upload" value=" Upload "></td>
</tr>
</table>
</form>
Okay, now let's take a look at the upload process. First we need to specify the directory to store the uploaded files. We store the directory name in $uploadDir. Note that PHP must have write access to $uploadDir or else the upload will fail. If you're web host using a Linux server you may need to set the permission for the upload directory to 777.
<?php
$uploadDir = 'C:/webroot/upload/';
if(isset($_POST['upload']))
{
$fileName = $_FILES['userfile']['name'];
$tmpName = $_FILES['userfile']['tmp_name'];
$fileSize = $_FILES['userfile']['size'];
$fileType = $_FILES['userfile']['type'];
$filePath = $uploadDir . $fileName;
$result = move_uploaded_file($tmpName, $filePath);
if (!$result) {
echo "Error uploading file";
exit;
}
include '../library/config.php';
include '../library/opendb.php';
if(!get_magic_quotes_gpc())
{
$fileName = addslashes($fileName);
$filePath = addslashes($filePath);
}
$query = "INSERT INTO upload2 (name, size, type, path ) ".
"VALUES ('$fileName', '$fileSize', '$fileType', '$filePath')";
mysql_query($query) or die('Error, query failed : ' . mysql_error());
include '../library/closedb.php';
echo "<br>Files uploaded<br>";
}
?>
The key here is the move_uploaded_file() function. This function will move the uploaded files from the temporary upload directory to the location that we earlier ( $uploadDir . $fileName ). If for some reason the functioncannot move the file it will return false and we exit the script because continuing the script is no use.
Downloading
For listing the download files we just need to copy from the previous script. The real difference start when you click on the download link.
if(isset($_GET['id']))
{
include '../library/config.php';
include '../library/opendb.php';
$id = $_GET['id'];
$query = "SELECT name, type, size, path FROM upload2 WHERE id = '$id'";
$result = mysql_query($query) or die('Error, query failed');
list($name, $type, $size, $filePath) = mysql_fetch_array($result);
header("Content-Disposition: attachment; filename=$name");
header("Content-length: $size");
header("Content-type: $type");
readfile($filePath);
include '../library/closedb.php';
exit;
}
After fetching the file info from the database and sending the required headers the next thing we need to do is read the file content from the server and send it to the browser. We can accomplish this by using readfile() function.
The Problems
When using this method of uploading files there are two problems that we need to take care of. They are :
1. Preventing direct access to the uploaded files
2. Handling duplicate file names
Preventing direct access
For this example the upload directory where the files are stored is /home/arman198/public_html/examples/upload/files/. Using your browser you see the upload directory by clicking here. This is ( usually ) a bad thing because anyone can see directly the file list and download them all. If you don't want to prevent people from seeing the content of the upload directory you could create an empty file, name it index.html then put that file to the upload directory. This is certainly not the optimal solution because maybe some people will try guessing the files names.
A better approach is to move the upload directory away from your web root. For example, the web root for this site is: /home/arman198/public_html/ to prevent direct listing i can set the upload directory to /home/arman198/upload/.
This way an outsider cannot see directly what's inside the upload directory. For example, even if you go to this url : http://www.php-mysql-tutorial.com/../upload/ you can't see the upload directory
Handling duplicate file names
When saving the files into the MySQL database we don't have to worry about this. The table for saving the files uses an id as the primary key so even we put ten files with the same name there won't be any problem since we access the files using that unique id.
The problem arise when saving the files to file server. The move_uploaded_file() function will overwrite a file with the same name and this is certainly not a desired behaviour.
To prevent this we just need to modify the file name. In this example the file names are changed into a random string, 32 characters long.
<?php
// ... same code as before
// get the file extension first
$ext = substr(strrchr($fileName, "."), 1);
// make the random file name
$randName = md5(rand() * time());
// and now we have the unique file name for the upload file
$filePath = $uploadDir . $randName . '.' . $ext;
$result = move_uploaded_file($tmpName, $filePath);
// ... same code as before
}
?>
First we extract the file extension from the file name using strrchr() function combined with substr(). Then using md5() we generate the 32 characters long of random string. It will look something like 7d1d1da5aac5ad72b293165e8e6fe89b. After we join them up we get the new unique file name. This way the chance of stumbling upon a duplicate name problem is very very slim.
As for the download part there's no change required. All we did was change the file name on the server so the previous download script will do just fine

Paging using PHP
Ever use a Search Engine? I'm sure you have, lots of time. When Search Engines found thousands of results for a keyword do they spit out all the result in one page? Nope, they use paging to show the result little by little.
Paging means showing your query result in multiple pages instead of just put them all in one long page. Imagine waiting for five minutes just to load a search page that shows 1000 result. By splitting the result in multiple pages you can save download time plus you don't have much scrolling to do.
To show the result of a query in several pages first you need to know how many rows you have and how many rows per page you want to show. For example if I have 295 rows and I show 30 rows per page that mean I'll have ten pages (rounded up).
For the example I created a table named randoms that store 295 random numbers. Each page shows 20 numbers.
Example: paging.php
Source code :paging.phps
<?php
include 'library/config.php';
include 'library/opendb.php';
// how many rows to show per page
$rowsPerPage = 20;
// by default we show first page
$pageNum = 1;
// if $_GET['page'] defined, use it as page number
if(isset($_GET['page']))
{
$pageNum = $_GET['page'];
}
// counting the offset
$offset = ($pageNum - 1) * $rowsPerPage;
$query = " SELECT val FROM randoms " .
" LIMIT $offset, $rowsPerPage";
$result = mysql_query($query) or die('Error, query failed');
// print the random numbers
while($row = mysql_fetch_array($result))
{
echo $row['val'] . '<br>';
}
// ... more code here
?>
Paging is implemented in MySQL using LIMIT that take two arguments. The first argument specifies the offset of the first row to return, the second specifies the maximum number of rows to return. The offset of the first row is 0 ( not 1 ).
When paging.php is called for the first time the value of $_GET['page'] is not set. This caused $pageNum value to remain 1 and the query is :
SELECT val FROM randoms LIMIT 0, 20
which returns the first 20 values from the table. But when paging.php is called like this http://www.php-mysql-tutorial.com/examples/paging/paging.php?page=4
the value of $pageNum becomes 4 and the query will be :
SELECT val FROM randoms LIMIT 60, 20
this query returns rows 60 to 79.
After showing the values we need to print the links to show any pages we like. But first we have to count the number of pages. This is achieved by dividing the number of total rows by the number of rows to show per page :
$maxPage = ceil($numrows/$rowsPerPage);
<?php
// ... the previous code
// how many rows we have in database
$query = "SELECT COUNT(val) AS numrows FROM randoms";
$result = mysql_query($query) or die('Error, query failed');
$row = mysql_fetch_array($result, MYSQL_ASSOC);
$numrows = $row['numrows'];
// how many pages we have when using paging?
$maxPage = ceil($numrows/$rowsPerPage);
// print the link to access each page
$self = $_SERVER['PHP_SELF'];
$nav = '';
for($page = 1; $page <= $maxPage; $page++)
{
if ($page == $pageNum)
{
$nav .= " $page "; // no need to create a link to current page
}
else
{
$nav .= " <a href=\"$self?page=$page\">$page</a> ";
}
}
// ... still more code coming
?>
The mathematical function ceil() is used to round up the value of $numrows/$rowsPerPage.
In this case the value of total rows $numrows is 295 and $rowsPerPage is 20 so the result of the division is 14.75 and by using ceil() we get $maxPage = 15
Now that we know how many pages we have we make a loop to print the link. Each link will look something like this:
<a href="paging.php?page=5">5</a>
You see that we use $_SERVER['PHP_SELF'] instead of paging.php when creating the link to point to the paging file. This is done to avoid the trouble of modifying the code in case we want to change the filename.
We are almost complete. Just need to add a little code to create a 'Previous' and 'Next' link. With these links we can navigate to the previous and next page easily. And while we at it let's also create a 'First page' and 'Last page' link so we can jump straight to the first and last page when we want to.
<?php
// ... the previous code
// creating previous and next link
// plus the link to go straight to
// the first and last page
if ($pageNum > 1)
{
$page = $pageNum - 1;
$prev = " <a href=\"$self?page=$page\">[Prev]</a> ";
$first = " <a href=\"$self?page=1\">[First Page]</a> ";
}
else
{
$prev = ' '; // we're on page one, don't print previous link
$first = ' '; // nor the first page link
}
if ($pageNum < $maxPage)
{
$page = $pageNum + 1;
$next = " <a href=\"$self?page=$page\">[Next]</a> ";
$last = " <a href=\"$self?page=$maxPage\">[Last Page]</a> ";
}
else
{
$next = ' '; // we're on the last page, don't print next link
$last = ' '; // nor the last page link
}
// print the navigation link
echo $first . $prev . $nav . $next . $last;
// and close the database connection
include '../library/closedb.php';
// ... and we're done!
?>
Making these navigation link is actually easier than you may think. When we're on the fifth page we just make the 'Previous' link point to the fourth. The same principle also apply for the 'Next' link, we just need to add one to the page number.
One thing to remember is that we don't need to print the 'Previous' and 'First Page' link when we're already on the first page. Same thing for the 'Next' and 'Last' link. If we do print them that would only confuse the one who click on it. Because we'll be giving them the exact same page.
We got a problem here...
Take a look at this slightly modified version of paging.php. Instead of showing 20 numbers in a page, I decided to show just three.
See the problem already?
Those page numbers are running across the screen! Yuck!
This call for a little modification to the code. Instead of printing the link to each and every page we will just saying something like "Viewing page 4 of 99 pages".
Than means we havel remove these code :
<?php
// ... the previous code
$nav = '';
for($page = 1; $page <= $maxPage; $page++)
{
if ($page == $pageNum)
{
$nav .= " $page "; // no need to create a link to current page
}
else
{
$nav .= " <a href=\"$self?page=$page\">$page</a> ";
}
}
// ... the rest here
?>
And then modify this one
<?php
// ...
// print the navigation link
echo $first . $prev . $nav . $next . $last;
// ...
?>
Into this
<?php
// ...
// print the navigation link
echo $first . $prev .
" Showing page $pageNum of $maxPage pages " . $next . $last;
// ...
?>
When there's more than one column involved in paging there isn't much that we need to modify. We only need to decide how to count the total number of rows we have in the table. Consider the student table. This table have five columns as shown in the SQL below.
CREATE TABLE student(
id INTEGER UNSIGNED NOT NULL AUTO_INCREMENT,
name VARCHAR(30) NOT NULL,
address VARCHAR(50) NOT NULL,
age TINYINT UNSIGNED NOT NULL,
register_date DATE NOT NULL,
PRIMARY KEY (id)
);
In the select query we just select all the columns. You can also use SELECT * instead of mentioning all the column names ( SELECT id, name, address, age, register_date ). But personally i prefer writing the column names in the query so that by reading the code i know what the column names in a table without having to check the database.
<?php
include 'library/config.php';
include 'library/opendb.php';
// how many rows to show per page
$rowsPerPage = 3;
// by default we show first page
$pageNum = 1;
// if $_GET['page'] defined, use it as page number
if(isset($_GET['page']))
{
$pageNum = $_GET['page'];
}
// counting the offset
$offset = ($pageNum - 1) * $rowsPerPage;
$query = "SELECT id, name, address, age, register_date
FROM student
LIMIT $offset, $rowsPerPage";
$result = mysql_query($query) or die('Error, query failed');
// print the student info in table
echo '<table border="1"><tr><td>Student Id</td><td>Name</td><td>Address</td><td>Age</td><td>Register Date</td></tr>';
while(list($id, $name, $address, $age, $regdate) = mysql_fetch_array($result))
{
echo "<tr><td>$id</td><td>$name</td><td>$address</td>
<td>$age</td><td>$regdate</td></tr>";
}
echo '</table>';
echo '<br>';
// ... more code here
?>
In this example we print the result in table. Before looping through the array we just echo the starting table code and the header which displays the column names. Then in the loop we just print the values in a HTML table row.
The next thing is finding out the total number of rows. There are several ways to do it. The first one is shown below. It's the same method used in previous examples. We just use the COUNT() function
<?php
// ... previous code here
// how many rows we have in database
$query = "SELECT COUNT(id) AS numrows FROM student";
$result = mysql_query($query) or die('Error, query failed');
$row = mysql_fetch_array($result, MYSQL_ASSOC);
$numrows = $row['numrows'];
// ... just the same code that prints the prev & next link
?>
You can also count any other columns since they all yield the same result. So your query can be rewritten into this :
<?php
// ...
$query = "SELECT COUNT(name) AS numrows FROM student";
// ...
?>
Or this :
<?php
// ...
$query = "SELECT COUNT(age) AS numrows FROM student";
// ...
?>
There is another way to count the total rows. Instead of using COUNT() function in the query you use a simple SELECT <column> and use myql_num_rows() to see how many rows returned.
Take a look at the code below. We now separate the query into two parts. One is the normal SELECT query and the second is the SQL that performs the paging. After finish printing the result you can reuse the first part of the query to find the total number of rows.
<?php
// ... same old code to get the page number and counting the offset
$query = "SELECT id, name, address, age, register_date
FROM student ";
$pagingQuery = "LIMIT $offset, $rowsPerPage";
$result = mysql_query($query . $pagingQuery) or die('Error, query failed');
// ... the code that prints the result in a table
// how many rows we have in database
$result = mysql_query($query) or die('Error, query failed');
$numrows = mysql_num_rows($result);
// ... and here is the code that print the prev & next links
?>
There is another advantage in separating the original query with the paging query. In case you only wish to list all student whose age is older than 15. You just need to modify the original query and you don't have to worry about changing the query to find the total number of rows. The example is shown below :
<?php
// ... same old code to get the page number and counting the offset
$query = "SELECT id, name, address, age, register_date
FROM student
WHERE age > 15";
$pagingQuery = "LIMIT $offset, $rowsPerPage";
$result = mysql_query($query . $pagingQuery) or die('Error, query failed');
// ... the code that prints the result in a table
// how many rows we have in database
$result = mysql_query($query) or die('Error, query failed');
$numrows = mysql_num_rows($result);
// ... and here is the code that print the prev & next links
?>
The disadvantage of this method is that the second execution of mysql_query() will retrieve all columns from the database. This is very useless since we're not going to use them. We only interested in finding the total rows returned by that query. In the end it's really up to you to decide which method you prefer.

Tabelle orizzontali e verticali
Tabella orizzontale
<?php
include("../includes/connectall.php"); //connessione al server
$result = mysql_query("SELECT * FROM menu WHERE `LangShort` LIKE 'EN' ORDER BY `Menu` ASC ",$db); //stringa di mysql
$i=0;
echo '<table align="center" width="75%" border="5" cellspacing="1" cellpadding="0" bordercolor="#00FFFF"><tr>';
do { ?>
<td align="center" bgcolor="#00FFFF">
<?php
echo '<b><i> <font size="2"><a href="', $myrow["PathFile"], '">', $myrow["Menu"], "</a></font></i></b>";
?>
<?php
if($i%6==0) //quante colonne vuoi
echo '</tr>
<tr>';
$i++;
} while ($myrow = mysql_fetch_array($result));
mysql_close();
?>
</tr>
</table>

Tabella verticale
<?php
include("../includes/connectall.php"); //connessione al server
$result = mysql_query("SELECT * FROM menu WHERE `LangShort` LIKE 'EN' ORDER BY `Menu` ASC ",$db); //stringa di mysql
echo "<table align=\"left\" border=\"5\" width=\"100\" cellspacing=\"3\" cellpadding=\"1\" bordercolor=\"#00FFFF\">";
while($myrow = mysql_fetch_array($result))
{
echo '<TR><td align="center" bgcolor="#00FFFF" width="100" height="44">';
echo '<b><i> <font size="2"><a href="', $myrow["PathFile"], '"><span style="text-decoration: none">', $myrow["Menu"], "<span></a></font></i></b>";
echo " </TD>";
echo "</TR>";
}
echo "</TABLE>";
mysql_close();
?>

Javascript effects within PHP (2 examples here, rollover and popup)
An easy and clean process:
1. Create javascripts in the head of the page
2. Create another page with nothing but the javascript effect
3. Inlcude the effect page
rollover.htm
<html>
<head>
<script language="JavaScript">
function MM_swapImgRestore() { //v3.0
var i,x,a=document.MM_sr; for(i=0;a&&i<a.length&&(x=a[i])&&x.oSrc;i++) x.src=x.oSrc;
}
function MM_swapImage() { //v3.0
var i,j=0,x,a=MM_swapImage.arguments; document.MM_sr=new Array; for(i=0;i<(a.length-2);i+=3)
if ((x=MM_findObj(a[i]))!=null){document.MM_sr[j++]=x; if(!x.oSrc) x.oSrc=x.src; x.src=a[i+2];}
}
function MM_findObj(n, d) { //v4.0
var p,i,x; if(!d) d=document; if((p=n.indexOf("?"))>0&&parent.frames.length) {
d=parent.frames[n.substring(p+1)].document; n=n.substring(0,p);}
if(!(x=d[n])&&d.all) x=d.all[n]; for (i=0;!x&&i<d.forms.length;i++) x=d.forms[i][n];
for(i=0;!x&&d.layers&&i<d.layers.length;i++) x=MM_findObj(n,d.layers[i].document);
if(!x && document.getElementById) x=document.getElementById(n); return x;
}
function popUp(URL) {
day = new Date();
id = day.getTime();
eval("page" + id + " = window.open(URL, '" + id + "', 'toolbar=0,scrollbars=0,location=0,statusbar=0,menubar=0,resizable=0,width=625,height=400,left =10,top = 10');");
}
</script>
</head>
<BODY>
<TABLE WIDTH="180" BORDER="0" CELLSPACING="0" CELLPADDING="1" BGCOLOR="#FFFFFF"><BR><BR>
<TR><TD><DIV ALIGN="CENTER"><A HREF="javascript:popUp('../tellfriend/tellfriend.php')"
ONMOUSEOUT="MM_swapImgRestore()" ONMOUSEOVER="MM_swapImage('e','','../email_over.gif',1)">
<IMG SRC="../email_base.gif" WIDTH="180" HEIGHT="20" BORDER="0" NAME="e"></A></DIV></TD></TR></TABLE><P> 
</P>
</BODY>
</html>

document.php
<?php
$f='<font face=verdana,arial,helvetica size=2 color=blue';
echo "<br>$f>Hello World</font>";
include "rollover.htm";
?>

Controllo della compilazione dei campi - Verificare la corretta compilazione di un Form (***************************)
Il controllo della corretta compilazione dei campi dei Form è certamente uno degli "argomenti caldi" del webmastering.
In questo tutorial vedremo appunto come è possibile (grazie a Javascript) controllare la corretta compilazione di un modulo online.
Precisamente, verificheremo:
1) Che i campi non vengano lasciati vuoti ( useremo: ... value == "" )
2) La corretta formattazione di un indirizzo e-mail ( useremo: ... value.indexOf("@") == -1 )
Vediamo il codice HTML:
<script language="Javascript">
function ControllaForm()
{
var controllo=false;
if (document.form1.utente_nome.value == "" )
{
controllo=true;
alert("Attenzione: Hai lasciato vuoto un campo obbligatorio.\nIl form non sarà inviato");
}
if (document.form1.utente_email.value.indexOf("@") == -1 )
{
controllo=true;
alert("Attenzione: L'E-MAIL inserita non e' valida.\nIl form non sarà inviato");
}
if (document.form1.utente_msg.value == "" )
{
controllo=true;
alert("Attenzione: Hai lasciato vuoto un campo obbligatorio.\nIl form non sarà inviato");
}
if (controllo){return false}else{return true}
}
// -->
</SCRIPT>
<form method="post" name="form1" action="nome_script.ext" OnSubmit="return ControllaForm(this)">
Tuo nome:<br>
<input type="text" name="utente_nome" size="20"><br>
Tua e-mail<br>
<input type="text" name="utente_email" size="20"><br>
<br>
Tuo messaggio:<br>
<textarea name="utente_msg" cols="40" rows="4"></textarea><br>
<br>
<input type="submit" value="INVIA">
</form>
Come è facile notare tutto il meccanismo si impernia su due tipi di controllo.
Il controllo per i campi vuoti è assolutamente intuitivo ( == "" ). Ecco la sintassi:
if (document.NOME_FORM.NOME_CAMPO.value == "" )
{
controllo=true;
alert("MESSAGGIO DI ALERT");
}
Mentre per la verifica dell'indirizzo e-mail abbiamo usato "indexOf" per cercare all'interno di quel campo la chiocciolina (@). Ecco la sintasi:
if (document.NOME_FORM.NOME_CAMPO.value.indexOf("@") == -1 )
{
controllo=true;
alert("MESSAGGIO DI ALERT");
}
Se la chiocciolina non viene trovata "indexOf" restituirà "-1" attivando il relativo alert.
Array di files all'interno di una stessa pagina
<TABLE>
<TR></TR>
<?php
#Crea una pagina web intabellando il contenuto della directory
#'.' è la cartella corrente nella quale vi trovate
$cartella = opendir('works/.');
while ($file=readdir($cartella)) {
$file_array[] = $file;
sort ($file_array);
}
foreach ($file_array as $file) {
if ($file == ".." || $file == "." || $file =="index.php" || $file =="links") {
continue;
}
echo "<tr><td><left>";
echo "<a href=\"works/$file\">$file</a>";
echo "</center></td></tr>";
}
unset($file_array); //SCARICA L'ARRAY
?>
<blockquote>
<p align="left"><i><b>Links:</b></i></p>
<TABLE>
<TR></TR>
<?php
#Crea una pagina web intabellando il contenuto della directory
#'.' è la cartella corrente nella quale vi trovate
$cartella = opendir('works/links/.');
while ($file=readdir($cartella)) {
$file_array[] = $file;
sort ($file_array);
}
foreach ($file_array as $file) {
if ($file == ".." || $file == "." || $file =="index.php" || $file =="links") {
continue;
}
echo "<tr><td><left>";
echo "<a href=\"works/links/$file\">$file</a>";
echo "</center></td></tr>";
}
unset($file_array); unset($file_array); //SCARICA L'ARRAY
?>
</TABLE>
</blockquote>

Protezione dei file su server APACHE
Per creare delle cartelle su un vostro sito web protette da password dovete fare:
1) Collegatevi via ftp al vostro sito web
2) Createvi un file di nome .htaccess con notepad con il seguente contenuto:
Codice:
AuthUserFile /percorso-sito/dir-protetta/.htpasswd
AuthGroupFile /dev/null
AuthName "Mia Directory Protetta"
AuthType Basic
<Limit GET>
require valid-user
</Limit>
Dovete personalizzare la riga AuthUserFile inserendo il percorso del file .htpasswd
In AuthName si inserite il nome che volete dare alla finestra di login (nell'esempio: Mia Directory Protetta)
N.B. il file .htaccess deve essere creato nella cartella che si vuole proteggere da password.
3) Creare il file .htpasswd.
In questo file andremo a scrivere la lista degli utenti autorizzati e la relativa password nel seguente formato:
nome:password
la password dovrà essere inserita in formato md5 per farlo accedete a questi siti:
http://webxtractions.com/cgi-bin/password.cgi
http://www.askapache.com/online-tools/htpasswd-generator/
inserite username e password che volete utilizzare per il vostro file e successivamente premete il tasto "Encrypt it".
ESEMPIO: user mike password pippo
>uscirà: mike:92gmxL87pzQW6
questo è quello che dovete inserire nel file .htpasswd
ATTENZIONE:
Il file .htpasswd e il file .htaccess NON DEVONO AVERE ALCUNA ESTENSIONE
CONSIGLI:
- Utilizzate password con lunghezza minima di 12 caratteri.
- La directory contenente il file .htpasswd dovrebbe trovarsi in una directory esterna a quella in cui è depositato il sito (se utilizzate un NAS Synology, vuol dire fuori dalla cartella "web"). Tale cartella dovrebbe avere un accesso esclusivo al solo amministratore del sistema.
Suddividere il contenuto di un testo su più pagine
Come suddividere il contenuto di un articolo su piu' pagine.
Immaginiamo di avere un articolo lungo tante righe e lo vogliamo suddividere in piu pagine, quello che dobbiamo fare e' mettere dei caratteri speciali ,ad esempio "[++]" nel punto in cui vogliamo che vi sia una nuova pagina.
<?
$articolo="Le pagine di un sito web devono essere ottimizzate al fine
di renderle idonee ad una corretta registrazione sui motori di ricerca.
L’ottimizzazione si ottiene analizzando, ed eventualmente modificando, [++]
sia i contenuti di ogni singola pagina sia la struttura globale
del sito. Proprio per evitare di dover modificare l’impostazione [++]
di molte pagine è bene tenere in considerazione fin dall’inizio della progettazione
del sito quali dovranno essere gli accorgimenti
utili in funzione del posizionamento nei motori di ricerca.";
// Suddivido il testo in piu' testi troncandolo quando trovo [++]
$pagine = explode("[++]", $articolo);
// Definisco la variabile che ci dice la pagina da visualizzare
$pagina = $_GET['pagina'];
// Se la pagina non e' stata ancora divisa, assegna il valore 1
if(strlen($pagina<=0)) $pagina = 1;
//setto l'indice corretto
$indice= $pagina - 1;
// Stampo la pagina richiesta
echo $pagine[$indice]."<br>";
//toale delle pagine
$totale=count($pagine) + 1;
//pagina attuale
$indice=$indice+1;
$tot=$totale-1;
echo "<br>pagina $indice di $tot<br>";
// Sistemo le pagine
echo"vai a pagina:";
for ($i = 1; $i < $totale; $i++){
echo "<a href=\"" . $_SERVER['php_self'] . "?pagina=$i\">$i</a> ";
}
?>

=============================
$result = mysql_query("SELECT racconto FROM campagnaunica");
//eventualmente aggiungi una clausola where alla query

if (!$result) {echo "query non valida";}
$racconto = mysql_fetch_array($result);

//adesso puoi dividere come vuoi attraverso la funzione substr()
for ($i = 0; i < (strlen($racconto)/50); $i++) {
echo substr($racconto, $i * 50, 50);
}
=============================
Suddividere dinamicamente un testo su più pagine
In questo articolo vedremo come suddividere un testo su più pagine.
Questo non è l'unico modo per farlo... ma è un metodo piuttosto efficace e molto semplice da utilizzare.
Nel nostro esempio inseriamo il testo che vogliamo suddividere all'interno di una variabile che chiameremo $testo (che fantasia!).
Ecco un esempio:
$testo = "<b>Pag 1:</b><br />Ciao, tutto bene?<br />Sì... tutto a posto![NP]";
$testo .= "<b>Pag 2:</b><br />Ciao, dove vivi?<br />A Milano![NP]";
$testo .= "<b>Pag 3:</b><br />Ciao, sei innamorato?<br />Moltissimo!";
Come avrete notato, oltre ad alcuni tag html, nel testo troviamo 2 volte la scritta "[NP]" (dove NP sta per "Nuova Pagina"), ed è proprio questa piccola scritta che ci permetterà, col metodo che andiamo ora a vedere, di suddividere in più pagine il nostro testo!
Ora vediamo il codice che farà il lavoro:
// Suddivido il testo sulla base delle occorrenze di [NP]
$tot_pages = explode("[NP]", $testo);
// Definisco la variabile che ci dice la pagina da visualizzare
$page = $_GET['page'];
// Se $page non è valorizzata o non è numerica le assegno il valore di 1
if (!$page || !is_numeric($page)) { $page = 1; }
// Stampo la pagina richiesta
echo "<p>" . $tot_pages[$page - 1] . "</p>"
// Creo i link per la navigazione delle diverse pagine
for ($i = 1; $i < count($tot_pages) + 1; $i++)
{
if ($i == $page) {
echo "<b>$i</b> ";
}else{
echo "<a href=\"" . $_SERVER['php_self'] . "?page=$i\">$i</a> ";
}
}
Lo script è davvero molto semplice: il motore del nostro codice è la funzione nativa explode che suddivide il nostro testo sulla base del separatore specificato creando una array. Fatto questo non resta che creare una semplice paginazione che ci consenta di visualizzare di volta in volta singoli elementi della nostra array corrispondenti, appunto, alla pagina selezionata.
==============================
Dividere il testo dopo tot parole senza spezzare la frase
Qui di seguito vi mostro come poter tagliare un testo dopo tot lettere senza dividere la parola
/**
tronca il testo senza tagliare la parola
*/
function troncaTesto($testo, $caratteri=40) {
if (strlen($testo) <= $caratteri) return $testo;
$nuovo = wordwrap($testo, $caratteri, "|");
$nuovotesto=explode("|",$nuovo);
return $nuovotesto[0]."...";
}
/**
$nuovoTesto = troncaTesto($descrizione, 150);
echo $nuovoTesto;
*/
?>
Creare un database di testo in PHP
Spesso potremmo aver necessità di utilizzare un database. Tuttavia, se si tratta di un piccolo script che non useremo spesso, invece di andare a creare tabelle su MySQL, possiamo utilizzare un semplice file di testo e andare a scrivere e leggere delle stringhe.
E’ chiaro che le limitazioni sono molte:
* deve trattarsi di una mole di dati molto piccola
* è più macchinoso scrivere e leggere
* non si possono fare query
Può comunque tornare utile ed è un buon punto di partenza per imparare a manipolare i file di testo con PHP.
Vediamo allora passo dopo passo come fare.
Aprire un file di testo: fopen()
La funzione fopen() apre un collegamento tra una risorsa, indicata dal parametro filename, ed un flusso:
<?php
$handle = fopen("/home/rasmus/file.txt","r");
$handle = fopen("/home/rasmus/file.gif","wb");
$handle = fopen("http://www.example.com/","r");
$handle = fopen("ftp://user:password@example.com/somefile.txt","w");
?>
Utilizzeremo fopen() per aprire il nostro database di testo.
Scrivere un file di testo: fwrite()
Sintassi: int fwrite ( resource $handle , string $string [, int $length ] )
Questa funzione scrive il contenuto di string nel flusso del file puntato da handle. Se l’argomento length è specificato, la scrittura si arresterà dopo aver scritto length byte o alla fine di string se si verificasse prima:
<?php
$filename = 'test.txt';
$somecontent = "Aggiunge questa riga al file\n";
// Verifica che il file esista e sia riscrivibile
if (is_writable($filename)) {
// In questo esempio apriamo $filename in append mode.
// Il puntatore del file è posizionato in fondo al file
// è qui che verrà posizionato $somecontent quando eseguiremo fwrite().
if (!$handle = fopen($filename, 'a')) {
echo "Non si riesce ad aprire il file ($filename)";
exit;
}
// Scrive $somecontent nel file aperto.
if (!fwrite($handle, $somecontent) === FALSE) {
echo "Non si riesce a scrivere nel file ($filename)";
exit;
}
echo "Riuscito, scritto ($somecontent) nel file ($filename)";
fclose($handle);
} else {
echo "Il file $filename non è accessibile";
}
?>
Ecco, con queste poche righe di codice abbiamo già creato uno script che aggiunge una frase al file test.txt.
Dobbiamo notare però, che i file si possono aprire con fopen() in diversi modi (nello script proposto si apre in sola letture alla fine del file).
Leggere un file di testo: fread()
La funzione fread() estrae un numero di byte dal file di testo (.txt).
Esempio:
<?
$file = fopen("test.txt","r");
$buffer = fread($file, 20);
?>
In questo caso abbiamo aperto un file di testo (test.txt) solo per leggerlo (r) ed abbiamo estratto 20 byte.
Per leggere tutto il file dobbiamo scrivere in questo modo:
<?
$file = fopen("test.txt","r");
$buffer = fread($file, filesize("test.txt"));
?>
Dove la funzione filesize() restituisce la grandezza totale del file.
Andare a capo: nl2br()
La funzione aggiunge un <br /> quando trova un ritorno a capo nel file di testo.
Esempio:
<?
$file = fopen("test.txt", "r");
$leggi = fread($file, filesize("test.txt"));
$content = nl2br($leggi);
fclose($file);
echo $content;
?>
Creiamo il nostro database testuale
Vediamo ora come applicare il tutto in un semplice database di testo.
Nel file test.txt inseriamo i dati nel seguente formato:
Nome:Cognome:email
Vediamo allora come leggere ed interpretare il file di testo:
<?
$percorso = file("test.txt");
while(list(,$value) = each($percorso)){
list($nome, $cognome, $email) = split("[:]", $value);
#Usiamo trim() per eliminare eventuali spazi vuoti
$params["nome"] = trim($nome);
$params["cognome"] = trim($cognome);
$params["email"] = trim($email);
#Stampiamo i risultati a video
echo $params["nome"]." - ".$params["cognome"]." - ".$params["email"]. "<br />";
}
?>
Ma se non siamo soddisfatti e vogliamo fare il tutto in automatico, possiamo creare un form simile:
codice form insert.php
<html>
<body>
<form method="post" action="insert2.php">
<fieldset>
<legend>Inserimento dati</legend>
Nome: <input type="text" name="nome" />
Cognome: <input type="text" name="cognome" />
E-mail: <input type="text" name="email" />
</fieldset>
<input type="submit" value="Calcola">
</form>
</body>
</html>
… per poi richiamarli da questa pagina e scriverli sul “database”:
script php insert2.php
<?
$nome = $_POST['nome'];
$cognome = $_POST['cognome'];
$email = $_POST['email'];
$somecontent = $nome."-".$cognome."-".$email."<br>";
$somecontent .= "\r\n";
$myFile = "test.txt";
$fh = fopen($myFile, 'at');
fwrite($fh, $somecontent);
?>
Ovviamente questo script è altamente sconsigliato nel caso si abbia una grande mole di dati o per fare query particolarmente complesse. Si presta invece ottimamente per salvare piccole quantità di dati strutturati, in modo da renderli persistenti anche senza un database.
Realizzare contatore per i click
Ecco un tutorial che realizzato soprattutto per le persone che non hanno un account MySql e vogliono sapere quante click hanno ricevuto su un determinato link. Ecco il codice:
$i; $i++)
{
$links[$i] = str_replace("\n", "", $links[$i]);
$result = explode("|", trim($links[$i]));

if ($result[1] == $link)
{
$result[2] = $result[2]+1;
fputs($fp, "$result[0]|$result[1]|$result[2]" . "\n");
}
else
{
fputs($fp, $links[$i] . "\n");
}
}
fclose($fp);
header("Location: " . $link);
}
?

Cambio immagine a ogni aggiornamento di pagina
Utile e semplice script che permetterà di visualizzare un’immagine diversa ogni volta che la pagina sarà aggiornata. Questa funzione e possibile eseguirla anche con Javascript, oggi scoprirete il codice per farla con Php:
?PHP
#Creiamo la funzione Random Pic
function random_pic()
{
#Creiamo una array con tutte le nostre immagini
$PIC[] = "picture-1.jpg";
$PIC[] = "picture-2.jpg";
$PIC[] = "picture-3.jpg";
$PIC[] = "picture-4.jpg";
$PIC[] = "picture-5.jpg";
$PIC[] = "picture-6.jpg";
$PIC[] = "picture-7.jpg";
#Contiamo gli elementi presenti nella array
$tot_PIC = count($PIC);
#Creiamo la procedura randomica
$tot_PIC = $tot_PIC - 1;
$RandomNum = rand(0,$tot_PIC);
$My_PIC= $PIC[$RandomNum];
#Stampiamo a video l'immagine selezionata randomicamente
print ("<img border='0' src='immagini/". $My_PIC ."'>");
}
#Richiamiamo la funzione...
random_pic();
?
E' possibile evitare che gli utenti del mio sito inseriscano caratteri dannosi attraverso i miei form?
Sì, certo.
PHP prevede una funzione apposita:
$stringa = HTMLspeciachars($stringa)
In questo modo verranno resi innocui tutti i caratteri html eventualmente inseriti all‘interno della stringa proveniente dal form.Data e Ora
La data e l'ora è quella del momento in cui il server invia la pagina al browser, quindi con il ricarico della pagina si aggiorna anche il risultato.
Codice: <?php echo date("d M Y - H:i:s");?>
Risultato: 09 Apr 2005 - 10:40:27
Siccome la data e l' ora può essere espressa in molteplici modi, un completo tutorial è presente su questa pagina sul sito ufficale Php (http://www.php.net)

Indirizzo Ip
L' indirizzo IP è un identificativo numerico a 32 bit che serve a identificare in maniera univoca un computer connesso alla rete internet. In genere sono costituiti da quattro gruppi di cifre decimali ciascuno dei quali è compreso tra 0 e 255 separati tra loro da un punto.
Codice: <?php echo $ip = getenv("REMOTE_ADDR");?>
Risultato: xxx.xxx.xxx.xxx (Questo è il tuo..)

Nome pagina corrente
Questo codice visualizza il nome della pagina (e suo percorso nel sito) che contiene il codice stesso.
Codice: <?php echo $PHP_SELF;?>
Risultato: /php-funzioni.php

Browser Internet
Browser internet o client web è un' applicazione che tramite un interfaccia grafica, pulsanti ed icone permette e semplifica la navigazione in internet ovviamente il più famoso e funzionale di tutti è Internet Explorer anche se il neonato Mozilla Firefox sembra avere un altrettanto roseo futuro, questo è un personale parere del tutto opinabile.
Codice: <?php echo $browser = getenv("HTTP_USER_AGENT");?>
Risultato: Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.0) (Questo è il tuo..)

Linguaggio Browser
Si può usare questa informazione ottenibile con questo semplice stringa di codice Php quando ad esempio di un sito web se ne dispone la traduzione in più lingue e si vorrebbe che al visitatore venisse visualizzata direttamente quella nella propria e non dover lasciare a lui l' onere di dover cliccare sul link giusto (la solita bandierina). Va detto però che sono pochi gli utenti che settano correttamente questa funzione nel loro browser, alcuni cancellano addirittura tutte le lingue come se questo servisse a identificarli (il termine fobia vi dice nulla!?!).
Codice: <?php echo $HTTP_ACCEPT_LANGUAGE;?>
Risultato: it (Questo è il tuo)

Nome Host
Il nome host è il nome del computer (provider) che vi fornisce la connessione ad internet (se non presente verrà visualizzato il solo numero Ip).
Codice: <?php echo $host = gethostbyaddr($REMOTE_ADDR);?>
Risultato: xxxxxxxxxxxx.it (Questo è il tuo)

Ultimo Aggiornamento
Se aggiornate spesso la vostra pagina web e volete che la data venga visualizzata sulla pagina, questa stringa di codice può venirvi utile.
Codice:<?php echo date( "d.m.Y h:i:s", getlastmod() );?>
Risultato: 02.04.2005 06:28:34

Upload dei file
Se gestisci un sito web, e vuoi dare la possibilità ai tuoi utenti di inviare file in una specifica locazione, bastano poche righe di codice PHP per risolvere il tuo problema.
Bisogna crearsi due pagine una contenente il form in ci l'utente selezionerà il file da inviare (upload.php) e un'altra in cui l'upload verrà effettuato fisicamente (verifica.php).
Nella pagina upload.php, dobbiamo appunto costruirci la form con cui l'utente può selezionare il file da inviare, la pagina conterrà il codice:
<html>
<body>
<form method=post action="verifica.php" enctype="multipart/form-data">
Inserisci il nome del file da inviare:
<input type=file name="uploadfile"><br>
<input type="submit" value="Invia">
</form>
</body>
</html>
Nella pagina verifica.php, inseriremo il codice:
<html>
<body>
<?php
echo "<pre>";
echo "Nome del file creato all'invio: $uploadfile<br>";
echo "Nome originale del file: $uploadfile_name<br>";
echo "Dimensioni del file in byte: $uploadfile_size<br>";
echo "Tipo di file: $uploadfile_type<br>";
echo "</pre>";
//Adesso controlliamo se c'è veramente un file
if($uploadfile == "none")
{
echo "Non sono stati iniati file<br>";
exit;
}
//Contollo le dimensioni
//Se meno di 3MB lo invio
if($uploadfile_size < 3145728)
{
if(copy($uploadfile,"percorsoscelto/uploadfile_name"))
{
echo "Invio del file riuscito";
//Disalloco il file temporaneo
unlink($uploadfile);
}
else
{
echo "Invio fallito";
}
}
else
{
echo "Invio fallito. Il file non può superare i 3 MB";
}
?>
</body>
</html>
Le righe in rosso verranno ignorate in quanto commenti.
Come avete visto, basta poco per realizzare un form che permette di inviare un file, tutto gioca su una variabile che abbiamo creato nella pagina upload.php:
$uploadfile
Da questa variabile abbiamo poi le variabili:
$uploadfile_name (nome della variabile ricevuta)
$uploadfile_size (dimensioni della variabile)
$uploadfile_type (Il tipo di file che stiamo inviando)
Creare un guestbook
costruire un libro degli ospiti, meglio conosciuto come Guestbook.
Cominciamo con l'aprire il nostro editor e a salvare il primo file, chiamandolo config.php e inserendoci questo codice:
<?php
$msg_per_page = 5;
$mysql['host'] = "";
$mysql['pass'] = "";
$mysql['user'] = "";
$mysql['name'] = "";
@mysql_connect($mysql['host'], $mysql['user'], $mysql['pass']);
@mysql_select_db($mysql['name']);
?>
La prima variabile, $msg_per_page, ci serve per indicare il numero di messaggi che si vogliono visualizzare per ogni pagina; ovviamente, il numero è arbitrario, ma lasciatevi dare un consiglio... non alzate troppo la cifra altrimenti chi non ha connessioni veloci potrebbe aver difficolt? alla visualizzazione della pagina.
La seconda variabile, $mysql, è un array, e ci serve per indicare i dati del nostro database MySQL.
In questo file non sono presenti altre variabili, ma già incontriamo due funzioni: mysql_connect() e mysql_select_db().
Come è facile intuire le due funzioni sono legate a MySQL, infatti, la prima serve per la connessione al server e la seconda per selezionare il database che si vuole usare.
Passiamo ora alla creazione della tabella nel database MySQL.
Aprire un nuovo documento vuoto e inserire all'intorno questo codice:
<?php
require("config.php");
@mysql_query("DROP TABLE IF EXISTS gbook");
@mysql_query("CREATE TABLE gbook (
`id` INT(11) DEFAULT '0' NOT NULL AUTO_INCREMENT,
`nome` VARCHAR(255) NOT NULL,
`email` VARCHAR(255) NOT NULL,
`url` VARCHAR(255),
`messaggio` TEXT NOT NULL,
`ip` VARCHAR(255) NOT NULL,
PRIMARY KEY (`id`)
);");
echo "Operazione avvenuta con successo !!\n";
@mysql_close();
?>
Non ci sono variabili ma sono presenti due query al database, la prima ci serve per cancellare la tabella se esiste già, la seconda per crearla.
Fatte attenzione, la tabella che serve a noi, si chiama "gbook", e se esiste già verrà cancellata e tutti i dati presenti verrano cancellati e non saranno recuperabili in alcun modo.
Dopo aver visto la parte di configurazione, cominciamo ad entrare nel vivo dell'applicazione.
Ora, aprire un nuovo documento vuoto e salvarlo come: leggi.php ed ecco il codice che dovrà contenere:
<?php
require("config.php");
$count_mess = @mysql_query("SELECT COUNT(id) FROM gbook");
$res_count = @mysql_fetch_array($count_mess);
if ($res_count[0] == FALSE) {
echo "Nessun messaggio ? stato inserito nel database";
} else {
$tot_pages = ceil($res_count[0]/$msg_per_page);
$curr_page = (!$_GET['page']) ? 1 : (int)$_GET['page'];
$primo = ($curr_page - 1) * $msg_per_page;
$query = mysql_query("SELECT * FROM gbook ORDER BY id DESC LIMIT $primo,$msg_per_page");
while($result = mysql_fetch_array($query)) {
$result['messaggio'] = str_replace("\n", "<br>", $result['messaggio']);
echo " <strong>? Nome:</strong> " . $result['nome'] . "<br>\n";
echo " <strong>? E-Mail:</strong> <a href=\"mailto:" . $result['email'] . "\">" . $result['email'] . "</a><br>\n";
echo " <strong>? URL:</strong> <a href=\"" . $result['url'] . "\">" . $result['url'] . "</a><br>\n";
echo " <strong>? Messaggio:</strong><br> " . $result['messaggio'] . "\n";
echo " <hr>\n";
}
for($page = 1; $page <= $tot_pages; $page++) {
if($page == $curr_page) {
$pag .= "<strong>$page</strong> ";
} else {
$pag .= "<a href=\"?page=$page\">$page</a> ";
}
}
echo $pag . "<br>\n";
}
echo "<a href=\"firma.php\">Firma il Guestbook</a>";
@mysql_close();
?>
Questo file servirà per visualizzare tutti i messaggi degli utenti.
Le prime due variabili, $count_mess e $res_count, ci serviranno per impaginare correttamente i messaggi presenti nel database.
Appena dopo queste due variabili ci troviamo davanti ad un if(), questo controllo ci è utile per vedere se sono presenti o meno messaggi nel database, se ce ne sono li stampa a video, in caso contrario viene fuori un messaggio di allerta.
Ora incontriamo tre variabile, che, anchesse servono per l'impaginazione dei messaggi.
Ed ecco finalmente che arriviamo alla parte 'importante' dello script.
Incontriamo subito la variabile $query che, tramite la funzione mysql_query() di php ci permette di inviare un 'comando' al database.
Subito dopo si nota un ciclo while() che serve per stampare a video il tutto.
Infine, stampiamo a video tutte le pagine tramie un ciclo for() e chiudiamo la connessione al database MySQL.
Nell'articolo precedente abbiamo visto come leggere i messaggi presenti nel database, ora vedremo come inserirli.
Creiamo un file chiamato firma.php e inseriamoci questo codice:
<?php
require("config.php");
if ($_POST['sign'] == FALSE) {
echo " <form action=\"firma.php\" method=\"POST\">\n";
echo " <strong>- Nome *</strong> <input type=\"text\" name=\"nome\"><br>\n";
echo " <strong>- E-Mail *</strong> <input type=\"text\" name=\"email\"><br>\n";
echo " <strong>- URL</strong> <input type=\"text\" name=\"url\"><br>\n";
echo " <strong>- Messaggio *</strong> <textarea name=\"messaggio\" cols=\"35\" rows=\"10\"></textarea><br>\n";
echo " <input type=\"hidden\" name=\"sign\" value=\"true\">\n";
echo " <input type=\"submit\" value=\" Firma! \">\n";
echo " </form>\n";
} else {
@mysql_query("INSERT INTO gbook (`id`, `nome`, `email`, `url`, `messaggio`, `ip`)
VALUES ('', '" . $_POST['nome'] . "',
'" . $_POST['email'] . "',
'" . $_POST['url'] . "',
'" . $_POST['messaggio'] . "',
'" . $_SERVER['REMOTE_ADDR'] . "');");
echo "Grazie per aver firmato il nostro Guestbook<br>";
echo "<a href=\"leggi.php\">Leggi i messaggi</a>\n";
}
@mysql_close();
?>
In questa parte del codice salta subito agli occhi che c'è un if(), che serve per controllare se una variabile è esistente o meno.
In caso positivo, inserisce il messaggio nel database tramite una query con la funzione mysql_query(), altrimenti visualizza il form.
Realizzare un sondaggio
Questo tutorial, vi mostra come creare un semplice ed utile sondaggio da inserire nel vostro sito, così potrete conoscere le opinioni dei vostri visitatori.
Per questo tutorial abbiamo bisogno di 3 files.
1. poll_global.php: Questo file contiene le informazioni per la connessione al database.
2. poll_main.php: Questa è la pagina che i visitatori vedono e nella quale votano.
3. poll_send.php: Questa è la pagina dei ringraziamenti.
Ho cercato di scrivere il codice più chiaro possibile, inserendo anche dei commenti per una migliore comprensione.
poll_global.php
<?
include("config.php");
//Connessione al database
@ $db = mysql_pconnect("$dbhost","$dbuname","$dbpass");
//Messaggio di errore nel caso che non avvenga una corretta connessione al database
if (!$db)
{
echo "<font color='red'><b>Impossibile collegarsi al database. Riprova più tardi!</b></font>";
exit;
}
//Seleziono il database
mysql_select_db("$dbname", $db);
?>
Questi sono i dati da inserire nel phpMyAdmin per creare la tabella per il nostro sondaggio.
CREATE TABLE vota (
ip varchar(15) NOT NULL default '',
vote int(11) NOT NULL default '0',
PRIMARY KEY (ip)
);
Se non sapete come fare per creare una tabella nel vostro database, utilizzate lo script qui sotto:
poll_table.php
<?
include ("poll_global.php");
$sql = "CREATE TABLE `vota` ( `ip` VARCHAR( 15 ) NOT NULL , `vote` INT NOT NULL , PRIMARY KEY ( `ip` ) )";
$result = mysql_query($sql);
?>
poll_main.php
<html>
<head>
<title>SONDAGGIO</title>
</head>
<body>
<center>
<h1><font color='#660066'>Sondaggio!!</font></h1>
<?
//includo poll_global.php
include ("poll_global.php");
//Qui viene acquisito l'indirizzo IP dell'utente
$ip = $_SERVER[REMOTE_ADDR];
//Selezioniamo l'intero database
$sql = "SELECT * FROM `database_table`";
$result = mysql_query($sql);
//Numero di voti presenti nel database
$number_of_vote = mysql_num_rows($result);
//Visualizziamo il numero di voti
echo "<h3>There are <b>$number_of_vote</b> votes</h3>";
//Variabile contatore
$i = 0;
$score =0;
//Calcoliamo la media dei voti
While ($i < $number_of_vote)
{
$score = $score + mysql_result($result, $i, vote);
$i++;
}
//Visualizziamo la media dei voti
echo "<h3>Average vote is ". number_format($score/$number_of_vote, 1) ."/5</h3>";
//Se l'utente ha già votato, apparirà un messaggio di errore
$i = 0;
While ($i < $number_of_vote)
{
if ($ip == mysql_result($result, $i, ip))
{
echo "Hai già votato!!";
exit;
}
$i++;
}
?>
//Inizio Form
<form action="poll_send.php" method="post">
<table>
<tr><td>
Cosa ne pensi di questo sito
</td></tr>
<tr><td>
<input type="radio" name="vote" value="5" checked>
Bellissimo!!!(5/5)
</td></tr>
<tr><td>
<input type="radio" name="vote" value="4"> Interessante (4/5)
</td></tr>
<tr><td>
<input type="radio" name="vote" value="3"> Carino (3/5)
</td></tr>
<tr><td>
<input type="radio" name="vote" value="2"> Così così (2/5)
</td></tr>
<tr><td>
<input type="radio" name="vote" value="1"> Non mi piace (1/5)
</td></tr>
<tr><td>
<input type="submit" value="Vota">
</td></tr>
</table>
</form>
</center>
</body>
</html>
poll_send.php
<html>
<head>
<title>SONDAGGIO</title>
</head>
<body>
<center>
<?
//Ricevo li valori delle variabili
$ip = $_SERVER[REMOTE_ADDR];
$vote = $HTTP_POST_VARS["vote"];
//Includo poll_global.php
include ("poll_global.php");
//Inserisco il voto nella tabella del database
$sql = "INSERT INTO `database_name` ( `ip` , `vote` ) VALUES ( '$ip', '$vote' )";
$result=mysql_query($sql);
//Ringrazio l'utente per il suo voto e gli indico la pagina principale dei risultati
echo "<h3>Grazie per aver votato!<br></h3>";
echo "<h3><a href='poll_main.php'>Clicca qui</a> per vedere i risultati del sondaggio!</h3>";
?>
</center>
</body>
</html>
Questo è tutto! Ricordati di inserire tutti i files nella stessa directory!
Eseguire l'upload di un file
Un'altra delle operazioni molto frequenti è quella che concerne l'upload di file online. Quando si parla di upload bisogna tenere in considerazione una serie di elementi per il corretto funzionamento dei propri script. Per prima cosa è necessario che il file php.ini sia configurato in modo da limitare correttamente le dimensioni dei file da caricare: se nella nostra applicazione è possibile effettuare l'upload di file molto grossi, è necessario modificare la variabile di configurazione max_upload_size affinché il suo valore sia adatto alla nostra situazione.
In secondo luogo è importante ricordarsi che i form HTML che devono inviare i file devono avere l'attributo enctype impostato a "multipart/form-data", altrimenti i file non saranno inviati correttamente. Infine è bene ricordare che i file caricati non sono salvati all'interno della variabile globale $_POST ma all'interno di $_FILES, dalla quale saranno accessibili anche altre informazioni addizionali come il nome del file temporaneo locale in cui è stato salvato il file inviato, le dimensioni del file ed altro.
Vediamo nel dettagli come effettuare l'upload di un file. Prima di tutto creiamo un semplice form HTML che si occuperà di richiedere all'utente l'inserimento di un file:
<html>
<head>
<title>File upload</title>
</head>
<body>
<form method="post" action="testupload.php" enctype="multipart/form-data">
<input type="hidden" name="action" value="upload" />
<label>Carica il tuo file:</label>
<input type="file" name="user_file" />
<br />
<input type="sumit" value="Carica online" />
</form>
</body>
</html>
Tengo a precisare che potremmo specificare un campo di input nascosto chiamato MAX_FILE_SIZE avente come valore la dimensione massima in byte del file da caricare. Questo valore, anche se controllato sia dal browser che da PHP, non è comunque sicuro, dato che può essere facilmente aggirato. È buona norma effettuare sempre la validazione dei dati da PHP prima di salvarli o elaborarli per evitare spiacevoli sorprese.
Tornando a noi, passiamo alla creazione del file testupload.php:
<?php
define("UPLOAD_DIR", "./uploads/");
if(isset($_POST['action']) and $_POST['action'] == 'upload')
{
if(isset($_FILES['user_file']))
{
$file = $_FILES['user_file'];
if($file['error'] == UPLOAD_ERR_OK and is_uploaded_file($file['tmp_name']))
{
move_uploaded_file($file['tmp_name'], UPLOAD_DIR.$file['name']);
}
}
}
?>
Queste poche righe di codice si occupano di controllare che i dati provenienti dalla pagina precedente siano corretti, controllano la validità del file caricato ed effettuano praticamente l'upload salvando i dati ove necessario.
L'array $_FILES permette di accedere ai seguenti valor:
* name: il nome del file caricato originariamente dall'utente;
* tmp_name: il nome temporaneo del file salvato da PHP in una cartella locale;
* type: il mime type del file (nel caso in cui il browser fornisca questa informazione);
* size: le dimensioni in byte del file;
* error: un codice numerico che indica l'eventuale errore durante il caricamento del file. Ad ogni numero possibile è associata una delle seguenti costanti:
o UPLOAD_ERR_OK (0): Non vi sono errori, l'upload è stato eseguito con successo;
o UPLOAD_ERR_INI_SIZE (1): Il file inviato eccede le dimensioni specificate nel parametro upload_max_filesize di php.ini;
o UPLOAD_ERR_FORM_SIZE (2): Il file inviato eccede le dimensioni specificate nel parametro MAX_FILE_SIZE del form;
o UPLOAD_ERR_PARTIAL (3): Upload eseguito parzialmente;
o UPLOAD_ERR_NO_FILE (4): Nessun file è stato inviato;
o UPLOAD_ERR_NO_TMP_DIR (6): Mancanza della cartella temporanea;
Con tutte queste informazioni risulta molto semplice analizzare un'operazione di upload e comportarsi di conseguenza. La funzione is_uploaded_file controlla che un file sia effettivamente uno di quelli caricati dall'utente, mentre move_uploaded_file effettua fisicamente lo spostamento del file temporaneo nel fiel di destinazione specificato.
Aggiungendo alcuni accorgimenti sulle dimensioni ed impacchettando tutto in una libreria è possibile gestire in modo molto completo il caricamento di file online senza rischiare di incorrere in problemi o malfunzionamenti. Come sempre è importante ricordarsi che il path di destinazione di move_uploaded_file deve essere un path valido.
Gestione dei file in PHP
Di seguito riporto alcuner istruzioni su come gestire i file in php:
Apertura file
<?
$file = fopen(nomefile.txt,"r");
?>
Chiusura file
<?
fclose($file);
?>
Modalità di apertura
a Apre il file per accodare informazioni
a+ Apre il file per le leggere/accodare informazioni
r Apre il file per sola lettura
r+ Apre il file per lettura e scrittura
w Apre il file per sola scrittura
w+ Apre il file per scrittura/lettura
Se si usa"a" e "r" il file deve già esistere.
Verifica apertura file
<?
if(!$file = fopen(nomefile.txt,"r"))
{
echo "Errore apertura file";
exit;
}
?>
Scrittura file
<?
fputs($file,"Questo è un file scritto con PHP ");
?>
Naturalmente al posto di una stringa, possiamo inserire una variabile che contiene il nostro testo.
Se si vogliono scrivere su più righe basta utilizzare:
"\r\n"
Leggere un file
<?
$testofile = fgets($file,255);
?>
Dove 255 sono i bytes da leggere
Apertura file
<?
$file = fopen(nomefile.txt,"r");
?>
Controlli sui file
<?
//Dimensioni di un file
filesize($file);
//Controllare se il file è una cartella
is_dir($file);
//Controllare se il file è ordinario
is_file($file);
//Controllare se è eseguibile
is_executable($file);
//Controllare se è leggibile
is_readble($file);
//Controlare se è scrivibile
is_writeable($file);
//Controllare il tipo
filetype($file);
?>
Aprire e leggere i contenuti di una cartella
<?
$lacartella = opendir('.');
while($file = readdir($lacartella)
{
$tutti_i_file[] = $file
}
?>
In questo modo avremo un arrey con tutti i file contenuti nella cartella corrente.
Se non usiamo il ciclo la funzione readdir legge solo il primo file della directory.
Evitare la ridondanza dei dati in un database
Nella maggior parte degli script che girano sul web e non solo è spesso necessario evitare la ridonzanda dei dati.
Supponiamo ad esempio di dover gestire la tabella degli iscritti al nostro sito e di fare in modo che ogni utente abbia una sua e-mail che lo identifichi univocamente. Sarà pertanto necessario bloccare le iscrizioni degli altri utenti se questi provano a registrarsi con un'indirizzo e-mail già esistente! Non a caso molte volte scegliendo l'username per l'iscrizione a un forum o a qualsiasi altro servizio vi sarà capitato di trovarvi con un messaggio del tipo "Username già in uso. Sceglierne un altro" e via discorrendo. Vediamo allora come fare sfruttando l'integrazione tra Php e MySql.
In questo esempio vedremo, nello specifico, un sistema di iscrizione ad una newsletter che consentirà di non avere risultati ridondanti. Sarà quindi possibile iscrivere un'indirizzo e-mail una ed una sola volta!
Grazie all'istruzione di Sql che vi propongo di seguito creiamo la tabella relativa ai dati dei nostri membri composta da id utente e rispettiva e-mail:
CREATE TABLE `newsletter_users` (
`id_user` int(11) NOT NULL auto_increment,
`email` varchar(40) NOT NULL default '',
PRIMARY KEY (`id_user`)
) TYPE=MyISAM AUTO_INCREMENT=1 ;
Una volta creata la tabella destinata a raccogliere i dati, procediamo con la realizzazione del form che ci permeterà di inserire l'indirizzo e-mail da iscrivere alla newsletter. Il codice (X)Html da inserire è il seguente:
<form id="subscription" name="subscription" method="post" action="controllo_iscrizione.php">
<strong>Iscriviti alle newsletter per le novità</strong> <br />
<input name="email" type="text" id="email" size="24" />
<input type="submit" name="Submit" value="Iscriviti" />
</form>
Possiamo salvare questa pagina come "iscrizione.php". Come potete notare il form punta alla pagina "controllo_iscrizione.php" che, come ben potete capire dal nome del file, è quella che riceve in input l'indirizzo e-mail, lo verifica e, se non presente nel database, lo inserisce. In caso contrario sarà comunicato all'utente che tale indirizzo e-mail è già presente nel database.
Ecco il codice della pagina "controllo_iscrizione.php" che analizzeremo attentamente:
<?php
include("config.php"); // richiamo il file per la connessione al database
$error = 0;
$error_type = "";
$email = $_POST['email'];
// controllo della mail
if (strlen($email) == 0) { $error++; $error_type .= "Mail non inserita"; }
if ((!eregi("^[a-z0-9][_\.a-z0-9-]+@([a-z0-9][0-9a-z-]+\.)+([a-z]{2,4})", $email)) && (strlen($email) > 0)) {
$error++; $error_type .= "Mail non valida<br />";
}
// fine controllo della mail
// se non ci sono errori inizio la procedura di iscrizione...
if ($error == 0) {
// controlliamo che l'utente non sia gia' iscritto (result = 1 vuol dire che l'utente esiste, 0 altrimenti)
$query = "SELECT COUNT(*) FROM newsletter_users WHERE email = '$email' ";
$result = @mysql_query($query, $conn);
$n_row = @mysql_fetch_array($result) or die ("Errore nell'applicazione. " . mysql_error());
//fine del controllo sull'esistenza dell'utente
// se non esiste nessun utente con la stessa mail (e quindi se l'utente non è già iscritto)...
if ($n_row[0] != 1) {
// inserisco l'utente nel database...
$query = "INSERT INTO newsletter_users (email) VALUES ('$email')";
if (mysql_query ($query, $conn)) { // se l'inserimento va a buon fine
echo "Ti ringraziamo per esserti iscritto alle newsletter!<br />" ;
} // chiude l'if
else
echo "Erorre durante l'inserimento nel database"; // se l'inserimento non va a buon fine
mysql_close($conn);
} // chiude l'if
else { // se esiste già un utente con quella mail glielo comunico
print "<div>Indirizzo " . $email . " già esistente. <a href=\"javascript:history.go(-1);\">Riprova</a> con un'altra mail.</div>";
}
} // chiudo if($error == 0)
// ... se invece ci sono errori sull'inserimento della mail (nulla o sintassi non valida), li stampo a video
else echo "Errore: " . $error_type;
?>
Il codice è abbondantemente commentato, ma ulteriori chiarimenti possono essere necessari. Analizziamo quindi il codice riga per riga:
include("config.php");
Questa riga serve a richiamare il file di connessione al database. Se non sapete come creare tale file, aprite una nuova pagina php ed inseriteci all'interno il seguente codice, salvandola in seguito come "config.php". Se necessario, modificatelo con i parametri di accesso al vostro database.
<?
$db_user = "root";
$db_pass = "";
$db_host = "localhost";
$db_name = "newsletter";
$conn = mysql_connect($db_host, $db_user, $db_pass);
mysql_select_db($db_name, $conn) or die ("Errore nella connessione al database");
?>
$error = 0
Inizializzo a 0 il numero degli errori. Tale variabile viene incrementata solo in presenza di errori, quindi se pari a 0 (non ci sono errori) procedo con l'iscrizione dell'email mentre se maggiore di 0 (ci sono errori) segnalo l'errore che verrà memorizzato nella variabile $error_type e stampato a video.
$error_type = ""
Inizializzata come stringa vuota, assume un valore solo se si sono verificati errori durante la compilazione del form come, ad esempio, mail non inserita o non valida.
$query = "SELECT COUNT(*) FROM newsletter_users WHERE email = '$email' ";
$result = @mysql_query($query, $conn);
$n_row = @mysql_fetch_array($result) or die ("Errore nell'applicazione. " . mysql_error());
Interrogo il database per vedere se l'indirizzo email inserito è già esistente o meno.
if ($n_row[0] != 1)
Serve a verificare che la query precedentemente lanciata restituisca un numero di risultati diverso da 1. Se il valore è pari a 1 vuol dire che l'indirizzo è già esistente, in caso contrario (diverso da 1) l'indirizzo non è presente nel database e pertanto lo inseriamo nello stesso tramite la query che analizziamo di seguito.
$query = "INSERT INTO newsletter_users (email) VALUES ('$email')";
Serve ad inserire l'email dell'utente solo nel caso in cui questo non sià già presente nel database.
Ovviamente questo codice è da considerarsi a scopo puramente didattico e non ha alcuna pretesa di completezza su come realizzare un sistema di iscrizione ad una newsletter.
Un sistema di login con le sessioni
Nelle lezioni precedenti abbiamo visto diverse volte come realizzare aree riservate tramite semplicissimi controlli if-else con i più noti linguaggi per il web. Tuttavia questi controlli sono da considerarsi poco sicuri in quanto username e password vengono definiti nella stessa pagina del controllo e quindi facilmente attaccabili.
Questa volta vedremo un sistema che, se progettato con il supporto di un database, può considerarsi più sicuro. Per esempio si può pensare ad un sito presso il quale l'utente può registrarsi scegliendosi un username ed una password ed accedere ogni volta con tali credenziali di accesso.
Utilizzando le sessioni di Php è possibile definire una variabile che viene mantenuta "attiva" per tutta la durata della sessione, ovvero fino a quando viene chiuso il browser o effettuato il logout.
Il sistema più sicuro sarebbe quello di controllare che la tupla inserita dall'utente in fase di login corrisponda a quella inserita in fase di registrazione (conservata nel database delle iscrizioni) e, in caso positivo, settare il valore della variabile di sessione ad esempio su "loggato" per mantenere lo stato dell'utente attivo per tutta la sessione di lavoro. Poichè il lavoro di progettazione con supporto del database richiederebbe appunto una progettazione dello stesso e uno studio approfondito di query e controlli, ci limiteremo a definire una tupla di accesso unica per tutti gli utenti che sarà memorizzata all'interno del file di controllo del login. Starà a voi "mixare" le vostre conoscenze sui database con quello che state per apprendere per poter realizzare quanto appena detto.
Prima di procedere, elenchiamo le pagine che faranno parte del nostro progetto, spiegandone attentamente la loro funzione.
* "form.php" sarà la pagina che conterrà il modulo di login nel quale l'utente dovrà digitare l'username e la password per poter accedere alla pagina riservata. In caso di login errato tale pagina sarà ricaricata per permettere un nuovo tentativo di riconoscimento.
* "controlla.php" conterrà innanzitutto le credenziali di accesso alla pagina riservata. Sarà inoltre incaricata al controllo del login e quindi al reindirizzamento alla pagina opportuna.
* "pagina_riservata.php" sarà appunto la pagina riservata alla quale si accederà in caso di login effettuato correttamente.
* "session_check.php" verrà inclusa in ogni pagina ad accesso riservato e servirà a non permettere l'accesso diretto tramite url dal browser nel caso il cui si conosca il percorso della pagina.
* "logout.php" sarà la pagina incaricata per la "distruzione" della sessione di login. Dopo aver caricato tale pagina, l'utente non sarà più riconosciuto dal browser e per accedere all'area riservata dovrà nuovamente effettuare il login.
Iniziamo pertanto ad analizzare il codice delle singole pagine. Partiamo dalla realizzazione della più semplice, "form.php", inserendo questo codice all'interno del tag <body>:
<form name="login" action="controlla.php" method="POST">
<h1>Fai il login:</h1>
<p>Username
<input type="text" name="username">
<br />
Password
<input type="text" name="password">
<br>
<input type="submit" value="Login">
</p>
</form>
Tale codice serve solamente alla creazione del form di login e non necessita di ulteriori chiarimenti.
Passiamo ora alla creazione del codice della pagina "controlla.php" che, come anticipato, servirà alla verifica della corrispondenza della tupla inserita dall'utente con quella definita all'interno della pagina stessa. Eccovi il codice che commenteremo opportunamente:
<?
$user = "user";
$pass = "password";
if ($_POST['username'] == $user && $_POST['password'] == $pass) {
session_start();
$_SESSION['login'] = "loggato";
header("Location: pagina_riservata.php");
} else {
header("Location: form.php");
}
?>
Innanzitutto abbiamo definito la tupla di accesso alla pagina riservata tramite le variabili $user e $pass. Successivamente, grazie ad un semplice controllo su una doppia condizione, abbiamo verificato che la tupla di accesso sia identica a quella inserita dall'utente nel form, i cui valori erano stati recuperati grazie alle variabili $_POST['username'] e $_POST['password']. Nel caso in cui il login è stato effettuato correttamente, viene avviata una sessione grazie alla funzione session_start() e definita la variabile di sessione $_SESSION['login'] alla quale viene associato il valore "loggato". Tale variabile, così inizializzata, garantirà l'accesso alla pagina "pagina_riservata.php", alla quale l'utente sarà rimandato. In caso di login errato l'utente sarà indirizzato nuovamente alla pagina "form.php" dalla quale potrà ritentare il login.
La pagina "pagina_riservata.php" conterrà appunto le informazioni riservate agli utenti loggati. Proprio per far capire che si tratta di una pagina riservata, abbiamo utilizzato il codice che vi viene fornito di seguito, ma ovviamente siamo liberi di personalizzarlo come meglio crediamo. Un paio di cose sono d'obbligo però:
* la riga <?php include("session_check.php"); // questa riga è d'obbligo ?> siamo tenuti a lasciarla in cima alla pagina, prima di qualsiasi tag html.
* la riga <p><a href="logout.php">ESEGUI IL LOGOUT</a> </p> possiamo posizionarla dove meglio crediamo, ma dobbiamo lasciarla così com'è in quanto permette all'utente di abbandonare la sessione di lavoro e di non essere più riconosciuto dal browser, salvo nuovo login.
Eccovi il codice completo della pagina:
<?php include("session_check.php"); // questa riga è d'obbligo ?>
<!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=iso-8859-1" />
<title>Untitled Document</title>
</head>
<body>
<h1>PAGINA RISERVATA</h1>
<p>contenuto della pagina riservata... </p>
<p><a href="logout.php">ESEGUI IL LOGOUT</a> </p>
</body>
</html>
Passiamo ora ad analizzare il brevissimo codice della pagina "session_check.php". Di seguito il codice, che sarà successivamente commentato:
<?
session_start();
if ($_SESSION['login'] != "loggato") {
header("Location: form.php");
}
?>
Innanzitutto ci tengo a precisare che questa è una pagina a sè stante che viene richiamata in ogni pagina che dovrà innanzitutto essere riservata, e che pertanto non dovrà essere raggiungibile direttamente puntando il browser all'url della pagina riservata. Supponendo infatti che il nostro sito sia "http://www.miosito.it", dobbiamo fare in modo, grazie all'inclusione di questa pagina, che digitando l'indirizzo "http://www.miosito.it/pagina_riservata.php" l'utente venga rimandato alla pagina di login e che non abbia quindi accesso ai contenuti della pagina, salvo dopo aver effettuato il login. Poichè la variabile di sessione $_SESSION['login'] assuse il valore "loggato" solo se l'utente ha eseguito correttamente il login, se il valore di tale variabile è diverso da "loggato" (o addirittura la variabile non è stata creata) l'utente dovrà essere rimandato alla pagina "form.php" per poter farsi riconscere.
Per ultimo, ma non per importanza, vediamo come permettere all'utente di abbandonare la sessione di lavoro grazie alla pagina "logout.php". Tale pagina potrà essere richiamata solamente tramite il link "Esegui il logout" contenuto nella pagina riservata. Dopo aver effettuato il logout l'utente non potrà più accedere alla pagina riservata, se non previo nuovo login. Eccovi il codice:
<?php
session_start();
$_SESSION = array();
session_destroy();
header("Location: form.php");
?>
Tramite la funzione session_start() abbiamo accesso alle eventuali variabili di sessione salvate in precedenza (nel nostro caso: $_SESSION['login']). Ci occuperemo successivamente di svuotare l'array $_SESSION grazie alla funzione array() e con la funzione session_destroy() provvediamo all'eliminazione del file contenente le variabili di sessione. Tramite header("Location: form.php"), infine, reindirizziamo l'utente al form di login per potersi nuovamente loggare.
Una volta compreso a pieno il codice potete personalizzarlo al meglio, ad esempio dando il benvenuto all'utente una volta loggato e salutandolo una volta effettuato il logout. Avendo poi le conoscenze su come far interagire il linguaggio Php con i database è possibile utilizzare le sessioni per creare potentissimi sistemi di login personalizzati ed aree riservate ad hoc per ogni singolo utente.
Realizzare un sondaggio
Questo tutorial, vi mostra come creare un semplice ed utile sondaggio da inserire nel vostro sito, così potrete conoscere le opinioni dei vostri visitatori.
Per questo tutorial abbiamo bisogno di 3 files.
1. poll_global.php: Questo file contiene le informazioni per la connessione al database.
2. poll_main.php: Questa è la pagina che i visitatori vedono e nella quale votano.
3. poll_send.php: Questa è la pagina dei ringraziamenti.
Ho cercato di scrivere il codice più chiaro possibile, inserendo anche dei commenti per una migliore comprensione.
poll_global.php
<?
include("config.php");
//Connessione al database
@ $db = mysql_pconnect("$dbhost","$dbuname","$dbpass");
//Messaggio di errore nel caso che non avvenga una corretta connessione al database
if (!$db)
{
echo "<font color='red'><b>Impossibile collegarsi al database. Riprova più tardi!</b></font>";
exit;
}
//Seleziono il database
mysql_select_db("$dbname", $db);
?>
Questi sono i dati da inserire nel phpMyAdmin per creare la tabella per il nostro sondaggio.
CREATE TABLE vota (
ip varchar(15) NOT NULL default '',
vote int(11) NOT NULL default '0',
PRIMARY KEY (ip)
);
Se non sapete come fare per creare una tabella nel vostro database, utilizzate lo script qui sotto:
poll_table.php
<?
include ("poll_global.php");
$sql = "CREATE TABLE `vota` ( `ip` VARCHAR( 15 ) NOT NULL , `vote` INT NOT NULL , PRIMARY KEY ( `ip` ) )";
$result = mysql_query($sql);
?>
poll_main.php
<html>
<head>
<title>SONDAGGIO</title>
</head>
<body>
<center>
<h1><font color='#660066'>Sondaggio!!</font></h1>
<?
//includo poll_global.php
include ("poll_global.php");
//Qui viene acquisito l'indirizzo IP dell'utente
$ip = $_SERVER[REMOTE_ADDR];
//Selezioniamo l'intero database
$sql = "SELECT * FROM `database_table`";
$result = mysql_query($sql);
//Numero di voti presenti nel database
$number_of_vote = mysql_num_rows($result);
//Visualizziamo il numero di voti
echo "<h3>There are <b>$number_of_vote</b> votes</h3>";
//Variabile contatore
$i = 0;
$score =0;
//Calcoliamo la media dei voti
While ($i < $number_of_vote)
{
$score = $score + mysql_result($result, $i, vote);
$i++;
}
//Visualizziamo la media dei voti
echo "<h3>Average vote is ". number_format($score/$number_of_vote, 1) ."/5</h3>";
//Se l'utente ha già votato, apparirà un messaggio di errore
$i = 0;
While ($i < $number_of_vote)
{
if ($ip == mysql_result($result, $i, ip))
{
echo "Hai già votato!!";
exit;
}
$i++;
}
?>
//Inizio Form
<form action="poll_send.php" method="post">
<table>
<tr><td>
Cosa ne pensi di questo sito
</td></tr>
<tr><td>
<input type="radio" name="vote" value="5" checked>
Bellissimo!!!(5/5)
</td></tr>
<tr><td>
<input type="radio" name="vote" value="4"> Interessante (4/5)
</td></tr>
<tr><td>
<input type="radio" name="vote" value="3"> Carino (3/5)
</td></tr>
<tr><td>
<input type="radio" name="vote" value="2"> Così così (2/5)
</td></tr>
<tr><td>
<input type="radio" name="vote" value="1"> Non mi piace (1/5)
</td></tr>
<tr><td>
<input type="submit" value="Vota">
</td></tr>
</table>
</form>
</center>
</body>
</html>
poll_send.php
<html>
<head>
<title>SONDAGGIO</title>
</head>
<body>
<center>
<?
//Ricevo li valori delle variabili
$ip = $_SERVER[REMOTE_ADDR];
$vote = $HTTP_POST_VARS["vote"];
//Includo poll_global.php
include ("poll_global.php");
//Inserisco il voto nella tabella del database
$sql = "INSERT INTO `database_name` ( `ip` , `vote` ) VALUES ( '$ip', '$vote' )";
$result=mysql_query($sql);
//Ringrazio l'utente per il suo voto e gli indico la pagina principale dei risultati
echo "<h3>Grazie per aver votato!<br></h3>";
echo "<h3><a href='poll_main.php'>Clicca qui</a> per vedere i risultati del sondaggio!</h3>";
?>
</center>
</body>
</html>
Ricordati di inserire tutti i files nella stessa directory!
Creare un guestbook
Vedremo come costruire un libro degli ospiti, meglio conosciuto come Guestbook.
Cominciamo con l'aprire il nostro editor e a salvare il primo file, chiamandolo config.php e inserendoci questo codice:
<?php
$msg_per_page = 5;
$mysql['host'] = "";
$mysql['pass'] = "";
$mysql['user'] = "";
$mysql['name'] = "";
@mysql_connect($mysql['host'], $mysql['user'], $mysql['pass']);
@mysql_select_db($mysql['name']);
?>
La prima variabile, $msg_per_page, ci serve per indicare il numero di messaggi che si vogliono visualizzare per ogni pagina; ovviamente, il numero è arbitrario, ma lasciatevi dare un consiglio... non alzate troppo la cifra altrimenti chi non ha connessioni veloci potrebbe aver difficolt? alla visualizzazione della pagina.
La seconda variabile, $mysql, è un array, e ci serve per indicare i dati del nostro database MySQL.
In questo file non sono presenti altre variabili, ma già incontriamo due funzioni: mysql_connect() e mysql_select_db().
Come è facile intuire le due funzioni sono legate a MySQL, infatti, la prima serve per la connessione al server e la seconda per selezionare il database che si vuole usare.
Passiamo ora alla creazione della tabella nel database MySQL.
Aprire un nuovo documento vuoto e inserire all'intorno questo codice:
<?php
require("config.php");
@mysql_query("DROP TABLE IF EXISTS gbook");
@mysql_query("CREATE TABLE gbook (
`id` INT(11) DEFAULT '0' NOT NULL AUTO_INCREMENT,
`nome` VARCHAR(255) NOT NULL,
`email` VARCHAR(255) NOT NULL,
`url` VARCHAR(255),
`messaggio` TEXT NOT NULL,
`ip` VARCHAR(255) NOT NULL,
PRIMARY KEY (`id`)
);");
echo "Operazione avvenuta con successo !!\n";
@mysql_close();
?>
Non ci sono variabili ma sono presenti due query al database, la prima ci serve per cancellare la tabella se esiste già, la seconda per crearla.
Fatte attenzione, la tabella che serve a noi, si chiama "gbook", e se esiste già verrà cancellata e tutti i dati presenti verrano cancellati e non saranno recuperabili in alcun modo.
Dopo aver visto la parte di configurazione, cominciamo ad entrare nel vivo dell'applicazione.
Ora, aprire un nuovo documento vuoto e salvarlo come: leggi.php ed ecco il codice che dovrà contenere:
<?php
require("config.php");
$count_mess = @mysql_query("SELECT COUNT(id) FROM gbook");
$res_count = @mysql_fetch_array($count_mess);
if ($res_count[0] == FALSE) {
echo "Nessun messaggio ? stato inserito nel database";
} else {
$tot_pages = ceil($res_count[0]/$msg_per_page);
$curr_page = (!$_GET['page']) ? 1 : (int)$_GET['page'];
$primo = ($curr_page - 1) * $msg_per_page;

$query = mysql_query("SELECT * FROM gbook ORDER BY id DESC LIMIT $primo,$msg_per_page");
while($result = mysql_fetch_array($query)) {
$result['messaggio'] = str_replace("\n", "<br>", $result['messaggio']);
echo " <strong>? Nome:</strong> " . $result['nome'] . "<br>\n";
echo " <strong>? E-Mail:</strong> <a href=\"mailto:" . $result['email'] . "\">" . $result['email'] . "</a><br>\n";
echo " <strong>? URL:</strong> <a href=\"" . $result['url'] . "\">" . $result['url'] . "</a><br>\n";
echo " <strong>? Messaggio:</strong><br> " . $result['messaggio'] . "\n";
echo " <hr>\n";
}
for($page = 1; $page <= $tot_pages; $page++) {
if($page == $curr_page) {
$pag .= "<strong>$page</strong> ";
} else {
$pag .= "<a href=\"?page=$page\">$page</a> ";
}
}
echo $pag . "<br>\n";
}
echo "<a href=\"firma.php\">Firma il Guestbook</a>";
@mysql_close();
?>
Questo file servirà per visualizzare tutti i messaggi degli utenti.
Le prime due variabili, $count_mess e $res_count, ci serviranno per impaginare correttamente i messaggi presenti nel database.
Appena dopo queste due variabili ci troviamo davanti ad un if(), questo controllo ci è utile per vedere se sono presenti o meno messaggi nel database, se ce ne sono li stampa a video, in caso contrario viene fuori un messaggio di allerta.
Ora incontriamo tre variabile, che, anchesse servono per l'impaginazione dei messaggi.
Ed ecco finalmente che arriviamo alla parte 'importante' dello script.
Incontriamo subito la variabile $query che, tramite la funzione mysql_query() di php ci permette di inviare un 'comando' al database.
Subito dopo si nota un ciclo while() che serve per stampare a video il tutto.
Infine, stampiamo a video tutte le pagine tramie un ciclo for() e chiudiamo la connessione al database MySQL.
Nell'articolo precedente abbiamo visto come leggere i messaggi presenti nel database, ora vedremo come inserirli.
Creiamo un file chiamato firma.php e inseriamoci questo codice:
<?php
require("config.php");
if ($_POST['sign'] == FALSE) {
echo " <form action=\"firma.php\" method=\"POST\">\n";
echo " <strong>- Nome *</strong> <input type=\"text\" name=\"nome\"><br>\n";
echo " <strong>- E-Mail *</strong> <input type=\"text\" name=\"email\"><br>\n";
echo " <strong>- URL</strong> <input type=\"text\" name=\"url\"><br>\n";
echo " <strong>- Messaggio *</strong> <textarea name=\"messaggio\" cols=\"35\" rows=\"10\"></textarea><br>\n";
echo " <input type=\"hidden\" name=\"sign\" value=\"true\">\n";
echo " <input type=\"submit\" value=\" Firma! \">\n";
echo " </form>\n";
} else {
@mysql_query("INSERT INTO gbook (`id`, `nome`, `email`, `url`, `messaggio`, `ip`)
VALUES ('', '" . $_POST['nome'] . "',
'" . $_POST['email'] . "',
'" . $_POST['url'] . "',
'" . $_POST['messaggio'] . "',
'" . $_SERVER['REMOTE_ADDR'] . "');");
echo "Grazie per aver firmato il nostro Guestbook<br>";
echo "<a href=\"leggi.php\">Leggi i messaggi</a>\n";
}
@mysql_close();
?>
In questa parte del codice salta subito agli occhi che c'è un if(), che serve per controllare se una variabile è esistente o meno.
In caso positivo, inserisce il messaggio nel database tramite una query con la funzione mysql_query(), altrimenti visualizza il form.
Eseguire l'upload di un file
Un'altra delle operazioni molto frequenti è quella che concerne l'upload di file online. Quando si parla di upload bisogna tenere in considerazione una serie di elementi per il corretto funzionamento dei propri script. Per prima cosa è necessario che il file php.ini sia configurato in modo da limitare correttamente le dimensioni dei file da caricare: se nella nostra applicazione è possibile effettuare l'upload di file molto grossi, è necessario modificare la variabile di configurazione max_upload_size affinché il suo valore sia adatto alla nostra situazione.
In secondo luogo è importante ricordarsi che i form HTML che devono inviare i file devono avere l'attributo enctype impostato a "multipart/form-data", altrimenti i file non saranno inviati correttamente. Infine è bene ricordare che i file caricati non sono salvati all'interno della variabile globale $_POST ma all'interno di $_FILES, dalla quale saranno accessibili anche altre informazioni addizionali come il nome del file temporaneo locale in cui è stato salvato il file inviato, le dimensioni del file ed altro.
Vediamo nel dettagli come effettuare l'upload di un file. Prima di tutto creiamo un semplice form HTML che si occuperà di richiedere all'utente l'inserimento di un file:
<html>
<head>
<title>File upload</title>
</head>
<body>
<form method="post" action="testupload.php" enctype="multipart/form-data">
<input type="hidden" name="action" value="upload" />
<label>Carica il tuo file:</label>
<input type="file" name="user_file" />
<br />
<input type="sumit" value="Carica online" />
</form>
</body>
</html>
Tengo a precisare che potremmo specificare un campo di input nascosto chiamato MAX_FILE_SIZE avente come valore la dimensione massima in byte del file da caricare. Questo valore, anche se controllato sia dal browser che da PHP, non è comunque sicuro, dato che può essere facilmente aggirato. È buona norma effettuare sempre la validazione dei dati da PHP prima di salvarli o elaborarli per evitare spiacevoli sorprese.
Tornando a noi, passiamo alla creazione del file testupload.php:
<?php
define("UPLOAD_DIR", "./uploads/");
if(isset($_POST['action']) and $_POST['action'] == 'upload')
{
if(isset($_FILES['user_file']))
{
$file = $_FILES['user_file'];
if($file['error'] == UPLOAD_ERR_OK and is_uploaded_file($file['tmp_name']))
{
move_uploaded_file($file['tmp_name'], UPLOAD_DIR.$file['name']);
}
}
}
?>
Queste poche righe di codice si occupano di controllare che i dati provenienti dalla pagina precedente siano corretti, controllano la validità del file caricato ed effettuano praticamente l'upload salvando i dati ove necessario.
L'array $_FILES permette di accedere ai seguenti valor:
* name: il nome del file caricato originariamente dall'utente;
* tmp_name: il nome temporaneo del file salvato da PHP in una cartella locale;
* type: il mime type del file (nel caso in cui il browser fornisca questa informazione);
* size: le dimensioni in byte del file;
* error: un codice numerico che indica l'eventuale errore durante il caricamento del file. Ad ogni numero possibile è associata una delle seguenti costanti:
o UPLOAD_ERR_OK (0): Non vi sono errori, l'upload è stato eseguito con successo;
o UPLOAD_ERR_INI_SIZE (1): Il file inviato eccede le dimensioni specificate nel parametro upload_max_filesize di php.ini;
o UPLOAD_ERR_FORM_SIZE (2): Il file inviato eccede le dimensioni specificate nel parametro MAX_FILE_SIZE del form;
o UPLOAD_ERR_PARTIAL (3): Upload eseguito parzialmente;
o UPLOAD_ERR_NO_FILE (4): Nessun file è stato inviato;
o UPLOAD_ERR_NO_TMP_DIR (6): Mancanza della cartella temporanea;
Con tutte queste informazioni risulta molto semplice analizzare un'operazione di upload e comportarsi di conseguenza. La funzione is_uploaded_file controlla che un file sia effettivamente uno di quelli caricati dall'utente, mentre move_uploaded_file effettua fisicamente lo spostamento del file temporaneo nel fiel di destinazione specificato.
Aggiungendo alcuni accorgimenti sulle dimensioni ed impacchettando tutto in una libreria è possibile gestire in modo molto completo il caricamento di file online senza rischiare di incorrere in problemi o malfunzionamenti. Come sempre è importante ricordarsi che il path di destinazione di move_uploaded_file deve essere un path valido.
Gestione dei file in PHP
Di seguito riporto alcuner istruzioni su come gestire i file in php:
Apertura file
<?
$file = fopen(nomefile.txt,"r");
?>
Chiusura file
<?
fclose($file);
?>
Modalità di apertura

Se si usa"a" e "r" il file deve già esistere
a	Apre il file per accodare informazioni
a+	Apre il file per le leggere/accodare informazioni
r	Apre il file per sola lettura
r+	Apre il file per lettura e scrittura
w	Apre il file per sola scrittura
w+	Apre il file per scrittura/lettura

Verifica apertura file
<?
if(!$file = fopen(nomefile.txt,"r"))
{
echo "Errore apertura file";
exit;
}
?>
Scrittura file
<?
fputs($file,"Questo è un file scritto con PHP ");
?>
Naturalmente al posto di una stringa, possiamo inserire una variabile che contiene il nostro testo.
Se si vogliono scrivere su più righe basta utilizzare:
"\r\n"
Leggere un file
<?
$testofile = fgets($file,255);
?>
Dove 255 sono i bytes da leggere
Apertura file
<?
$file = fopen(nomefile.txt,"r");
?>
Controlli sui file
<?
//Dimensioni di un file
filesize($file);
//Controllare se il file è una cartella
is_dir($file);
//Controllare se il file è ordinario
is_file($file);
//Controllare se è eseguibile
is_executable($file);
//Controllare se è leggibile
is_readble($file);
//Controlare se è scrivibile
is_writeable($file);
//Controllare il tipo
filetype($file);
?>
Aprire e leggere i contenuti di una cartella
<?
$lacartella = opendir('.');
while($file = readdir($lacartella)
{
$tutti_i_file[] = $file
}
?>
In questo modo avremo un arrey con tutti i file contenuti nella cartella corrente.
Se non usiamo il ciclo la funzione readdir legge solo il primo file della directory.

Realizzare un semplice contatore
Per realizzare un semplice contatore php bastano poche righe di codice e il gioco è fatto.
Il codice da utilizzare per la realizzazione del contatore è questo:
<?
$var=@fopen("contatore.txt",'r');
$leggi=@fread($var,filesize("contatore.txt"));
@fclose($var);
if ($leggi==null)
{
$leggi=1;
}
else
{
$leggi = $leggi+1;
}
$var=@fopen("/indirizzo_directory/...../contatore.txt",'w');
@fwrite($var,$leggi);
@fclose($var);
echo "N° Visite: ",$leggi,"";
?>
Questo contatore si serve di un file di testo contatore.txt per segnare le visite.
E' semplice da implementare ma ha un principale problema, ovvero: che si aggiorna a ogni refresh.
Questo problema però, può essere eliminato con l'utilizzo dei cookie.
=====================================================
Realizzare un piccolo contatore
Il contatore che andremo a costruire, crea un cookie nel computer dell'utente con il suo IP e aggiorna il conteggio in base allo stato del cookie. Se il cookie è presente e l'IP scritto nel cookie è lo stesso IP dell'utente corrente, allora lo script riconosce l'utente e sa che ha già visitato il sito oppure se è presente il cookie, ma l'IP è diverso da quello dell'utente corrente oppure non è presente, lo script sa che l'utente è nuovo oppure che il cookie è scaduto, allora aggiorna il conteggio. Questo script usa la funzione setcookie(), la quale deve essere inviata prima di inviare gli headers. Questo significa che questa funzione dve essere inserita prima del codice HTML. Il conteggio, per comodità, viene inserito in un file di testo ma se volete potete usare anche un database. Ecco il codice.
$c_ip = $HTTP_COOKIE_VARS["user_ip"];
$counter_file = "counter/count.txt";
$counter_file_line = file($counter_file); if(!$c_ip) {
setcookie("user_ip", $REMOTE_ADDR, time()+360000); $counter_file_line[0]++;
$cf = fopen($counter_file, "w+");
fputs($cf, "$counter_file_line[0]"); fclose($cf);
}
elseif($c_ip != $REMOTE_ADDR){
$counter_file_line[0]++; $cf = fopen($counter_file, "w+");
fputs($cf, "$counter_file_line[0]");
fclose($cf);
}
Ora analizziamo lo script pezzo per pezzo.
$c_ip = $HTTP_COOKIE_VARS["user_ip"];
$counter_file = "counter/count.txt";
$counter_file_line = file($counter_file);
La prima riga assegna un nome ad una variabile. La variabile che abbiamo nominato, è la variabile che farà riferimento al nostro cookie se lo script lo ha creato in precedenza. Non è obbligatorio usare $HTTP_COOKIE_VARS[] per rimandare a un cookie, generalmente può essere chiamato col suo nome com una variabile (es. $user_ip). La seconda variabile, indica dove il file di testo per il contatore deve essere memorizzato. Questa directory può essere modificata in base alle esigenze di ognuno. La terza variabile apre il file di testo e ne scrive il contenuto in un array usando la funzione file().
if(!$c_ip) {
Questa riga è la nostra istruzione if() che controlla la presenza della nostra variabile.
setcookie("user_ip", $REMOTE_ADDR, time()+360000);
Questa riga crea il nostro cookie. Se non capite il funzionamento della funzione setcookie() fae riferimento al manuale del PHP per magiori detagli, ma fondamentalmente viene creato un cookie col nome "user_ip" e il suo valore è l'IP dell'utente. Il terzo argomento è il tempo che trascorrerà prima che il cookie venga cancellato e richiama la funzione time(). Come si può vedere, c'è scritto time()+360000 che significa l'ora corrente più 360000 secondi. Questo è il numero che ho scelto per il mio script ed è un valore accettabile prima che il cookie venga eliminato comunque può essere modificato a piacimento. Se non inserite il terzo elemento, il cookie non verrà mai eliminato, dovrete farlo a mano. Questo codice viene usato solamente se il server non trova il cookie richiesto.
$counter_file_line[0]++;
$cf = fopen($counter_file, "w+");
fputs($cf, "$counter_file_line[0]");
fclose($cf);
}
Questa è la parte di codice che aggiunge le informazioni al contatore. La prima riga aggiunge il numero 1 al valore della prima riga nel file di testo. La seconda riga apre il file per modificarlo ed inserirci i dati. La terza riga scrive i nuovi dati nel file di testo. Infine, l'ultima riga chiude il file.
elseif($c_ip != $REMOTE_ADDR) {
Queste righe controllano il valore del cookie. Se il valore del cookie non è uguale all'IP dell'utente corrente questa parte di codice viene saltata.
$counter_file_line[0]++;
$cf = fopen($counter_file, "w+");
fputs($cf, "$counter_file_line[0]");
fclose($cf);
}
Per questa riga non servono spiegazioni. Per visualizzare il contatore ci serve solo una riga di codice come quella illustrata qui sotto.
echo $counter_file_line[0];
Il codice riportato qui sotto, visualizza il contatore. Se volete visualizzare il contatore in una pagina diversa da quella che dove è inserito il codice che incrementa il contatore, usa questo:
$counter_file = "counter/count.txt";
$counter_file_line = file($counter_file);
echo $counter_file_line[0];
Configurare php per l'invio di e-mail in locale
Inviare email da ambiente locale
Quando si sviluppano, in ambiente locale, degli script in PHP che devono inviare email, molto spesso il test in locale non funziona perchè PHP non riesce a trovare il server SMTP da utilizzare per la posta in uscita.
Per fare in modo che PHP utilizzi il server SMTP a nostra disposizione è sufficiente aprire con un editor di testi, il file di configurazione di PHP che si chiama php.ini, situato nella directory principale del proprio sistema operativo (directory WINDOWS per XP), individuare la stringa smtp e impostarla con il proprio server SMTP preferito.
Per esempio: se utilizzate Libero.it impostate la riga nel seguente modo:
smtp = smtp.libero.it
In questo modo sarete in grado di testare anche in locale gli script PHP che inviano email.
Aggiornare automaticamente il copyright all'anno attuale
In fondo ad ogni sito spesso è possibile trovare scritte del tipo "Tutti i diritti riservati © 2005", che spesso vengono inserite manualmente in puro Html.
Ma cosa facciamo la notte di S. Silvestro? Invece di festeggiare e stappare lo spumante pensiamo a cambiare l'anno del copyright in "2006"?... Non credo proprio.
Per evitare che la gente che si colleghi da quel momento fino a prima del nostro aggiornamento trovi ancora il copyright "aggiornato" al 2005 useremo la funzione date() di Php che recupererà e stamperà a video solo l'anno, a partire dalla data corrente.
Lo script andrà così realizzato:
<?php
$anno = date ("Y");
print "Tutti i diritti riservati © $anno";
?>
Ora potete festeggiare tranquillamente con i vostri amici e parenti senza pensare all'aggiornamento del copyright.
Il modulo Segnala ad un amico
In questo tutorial vedremo come realizzare un modulo cosiddetto "Tell a friend", ossia un form mail attraverso cui un visitatore può segnalare ad un amico un sito web.
Lo script si compone di due pagine:
- modulo.htm , contenente il form per l'inserimento dei dati;
- send.php , contenente il codice PHP per l'invio dell'email.
Apriamo quindi il nostro editor HTML o testuale e digitiamo il codice di 'modulo.htm' :
<form method="post" action="send.php">
Il tuo nome<br />
<input name="nomemittente" type="text" size="50" />
<br />
Il tuo indirizzo e-mail<br />
<input name="emailmittente" type="text" size="50" />
<br />
Il nome dell'amico<br />
<input name="nomedestinatario" type="text" size="50" />
<br />
L'indirizzo e-mail dell'amico<br />
<input name="emaildestinatario" type="text" size="50" />
<br />
<input type="submit" value="Invia segnalazione" />
<input type="reset" value="Cancella segnalazione" />
</form>
Il codice qui sopra riguarda logicamente solo il form, e quindi dovremo aggiungerlo alla struttura di base, formata dai tag classici ed indispensabili, quali <HTML>, <HEAD> e <BODY>.
Procediamo ora con la realizzazione di 'send.php' ; per spirito di eleganza, realizzeremo un codice PHP che invii l'email in formato HTML, basandoci su quanto detto in un altro tutorial:
<?PHP
// Processo di recupero dei dati
$nomemittente = $_POST['nomemittente'];
$emailmittente = $_POST['emailmittente'];
$nomedestinatario = $_POST['nomedestinatario'];
$emaildestinatario = $_POST['emaildestinatario'];
// Configuro il testo del messaggio che apparirà all'amico
$messaggio = "Ciao $nomedestinatario, ricevi questa mail perchè $nomemittente ti ha consigliato di visitare AG web solutions";
// Processo di controllo [Opzionale]
if ($nomemittente==null)
{
echo ("Errore: compilare il campo 'Il tuo nome'");
}
else
{
if ($emailmittente==null)
{
echo ("Errore: compilare il campo 'Il tuo indirizzo e-mail'");
}
else
{
if ($nomedestinatario==null)
{
echo ("Errore: compilare il campo 'Il nome dell'amico'");
}
else
{
if ($emaildestinatario==null)
{
echo ("Errore: compilare il campo 'Indirizzo e-mail dell'amico'");
}
else
{
// Processo di configurazione dell'email
// [Destinatario, mittente, ecc]
$mail_to = $emaildestinatario;
$mail_from = $emailmittente;
$mail_subject = "$nomemittente ti segnala AG web solutions";
$mail_body = "<p><font color=#000000>$messaggio</font></p>";
// Intestazioni HTML
$mail_in_html = "MIME-Version: 1.0\r\n";
$mail_in_html .= "Content-type: text/html; charset=iso-8859-1\r\n";
$mail_in_html .= "From: <$mail_from>";
// Processo di invio
if (mail($mail_to, $mail_subject, $mail_body, $mail_in_html))
{
echo ("E-mail inviata con successo");
}
else
{
echo ("Errore interno durante l'invio...");
}
}
}
}
}
?>
Il codice è sufficientemente commentato, e presenta un processo di recupero dei dati iniziale, seguito da un controllo e dal processo di invio. Salviamo i files e proviamo a testare lo script.
Operazioni sulle stringhe con Php
Con questo tutorial impareremo a lavorare con le stringhe in Php. Sappiamo benissimo che anche con i Css è possibile modificare del testo. La differenza sostanziale sta nel fatto che mentre con i Css modifichiamo solo la visualizzazione, con Php modifichiamo la stringa vera e propria.
Ve ne chiedete l'utilità di tutto ciò? Supponete di avere a che fare con un form e volete che tutti i dati in esso inseriti siano scritti in maiuscolo. Dato che ogni utente ha il suo modo di compilare i form, saremo noi a risolvere questo problema.
Innanzitutto ecco un codice che effettua tutte le possibili operazioni su stringhe:
<?php
//definisco la stringa su cui operare
$stringa = "visita sassidesign";
//operazioni con le stringhe
$strtolower = strtolower($stringa); //la stringa rimane tale perchè è già minuscola
$strtoupper = strtoupper($stringa);
$ucfirst = ucfirst($stringa);
$ucwords = ucwords($stringa);
//stampo tutte le variabili
echo "Il risultato con strtolower() è: $strtolower <br />";
echo "Il risultato con strtoupper() è: $strtoupper <br />";
echo "Il risultato con ucfirst() è: $ucfirst <br />";
echo "Il risultato con ucwords() è: $ucwords <br />";
?>
Il codice è abbastanza commentato. Vediamo comunque in dettaglio le possibili funzioni:
strtolower()
Converte l'intera stringa in minuscolo. Nel nostro caso la funzione non convertirà niente, dato che la stringa di partenza è già in minuscolo;
strtoupper()
Converte l'intera stringa in maiuscolo;
ucfirst()
Converte la prima lettera della stringa in maiuscolo;
ucwords()
Converte la prima lettera di ogni parola in maiuscolo.
Ma veniamo al nostro problema. Vogliamo che tutti i dati inseriti nel form vengano immagazzinati nel database in maiuscolo. Ecco come fare:
<?
$username = $_POST['username']; //recupero dal form
$usernamemaiuscolo = strtoupper($username); //converto in maiuscolo
// inserimento nel database della variabile 'usernamemaiuscolo' e non di 'username'
?>
Generare password casuali
Quante volte avete dimenticato una password? E quante volte che avete eseguito le operazioni di recupero della password vi è arrivata una mail con una password di lettere e numeri random?
Bhe, ecco un codice semplice ma che fa il suo dovere grazie alle funzioni rand e chr di php.
<?php
// Lunghezza della password da generare
$lunghezza_password = 10;
for ( $k=1;$k<=$lunghezza_password;$k++ )
{
// $k multiplo di 3
if ( $k % 3 )
{
// Scegliamo se maiuscola o minuscola
if ( rand( 0,200 ) <= 100 )
{
// Maiuscola
// Nella tabella ASCII da 65 a 90 ci sono le lettere dell'alfabeto Maiuscole
$newpass .= chr( rand ( 65,90 ) );
}
else
{
// Minuscola
// Nella tabella ASCII da 97 a 122 ci sono le lettere dell'alfabeto Minuscole

$newpass .= chr( rand ( 97,122 ) );
}
}
// $k non è multiplo di 3
else
{
// Inseriamo un numero
$newpass .= rand( 0,9 );
}
}
print $newpass;
?>
Con questo piccolo script, generiamo una stringa di lunghezza a vostra scelta composta da lettere (maiscole e minuscole) e numeri.
La funzione rand non fa altro che generare un numero casuale. Se non gli viene passato nessun range, sceglie autonomamente. La funzione chr recupera il valore nella tabella ASCII corrispondente al numero che gli viene passato.
Variabili PHP
Ricavare la posizione sul server di una pagina web
Avete mai visto un sito che indica: Ti trovi in...
Bene, per fare in modo che sulla vostra pagina web appaia il percorso non dovete fare altro che inserire queste poche righe:
<?php print ("Sei in: "); ?>
<?php $currentPage = $_SERVER["PHP_SELF"];
print ($currentPage); ?>
Testate tutto e dovreste avere come output: Sei in: /nomecartella/nomepagina.php
Recuperare la provenienza dell'utente
Avete notato come molti siti che offrono un servizio di statistica per il nostro sito danno anche la possibilità di controllare i siti da cui provengono gli utenti?
Beh, per fare una cosa del genere viene usato questo piccolissimo script che recupera l'indirizzo della pagina di provenienza dell'utente...
<?php
$refer = $_SERVER['HTTP_REFERER'];
echo ($refer);
?>
Recuperare l'indirizzo IP del visitatore
Molte volte, per svariati motivi, ci può essere utile conoscere l'indirizzo IP (Internet Protocol) dei nostri visitatori, specie nelle applicazioni che riguardano operazioni di scrittura, modifica o eliminazione su database.
Dobbiamo sapere innanzitutto che generalmente il nostro IP è dinamico, nel senso che ogni volta che chiudiamo una sessione internet e ne riapriamo un'altra, questo indirizzo IP cambia.
L'indirizzo è formato da quattro numeri che possono variare tra 0 e 255 separati da un punto; quando lavoriamo in locale il nostro IP è 127.0.0.0, ma un esempio potrebbe benissimo essere 211.20.34.87.
Recuperare l'indirizzo IP del visitatore è molto facile; il comando per stamparlo a video è questo,
<?php echo $REMOTE_ADDR ?>
ma potete modificare questa riga per fare in modo che l'indirizzo venga salvato su un file di testo o su un database!
Conoscere la versione installata del Php
Capita spesso, specie a chi è alle prime armi con il php, di trovarsi dinanzi alla necessità di sapere quale versione di php è installata nel PC. Per esempio può capitare di dover scegliere se usare gli array $HTTP_POST_VARS[] e $HTTP_GET_VARS[] o i nuovi ed equivalenti array $_POST[] e $_GET[] dato che questi ultimi hanno sostituito i precedenti già dalla versione 4.1.0 di PHP.
La procedura per conoscerla è la seguente:
* Aprire l'editor PHP (anche il classico notepad)
* Creare una nuova pagina PHP, immettendo in essa questa riga di codice:
<?php phpinfo(); ?>
* Salvare la pagina
* Lanciare ora la pagina sul vostro server locale. Apparirà una tabella dove sarà fornita la risposta al vostro interrogativo!
Dettagli sul client dell'utente
Per meglio capire il funzionamento facciamo un esempio pratico verificando il browser del nostro visitatore. Per fare ciò utilizzeremo una delle variabili di sistema. Sto parlando della variabile globale $_SERVER['HTTP_USER_AGENT'];.
Per prima cosa visualizziamo cosa contiene questa variabile con il seguente codice per pura curiosità:
<?php
print $_SERVER['HTTP_USER_AGENT'];
?>
Con questo semplice codice abbiamo detto al nostro server di stampare a video il contenuto della variabile. Per rendere un pò più dinamico introduciamo un controllo if-else:
<?php
if ( strstr($_SERVER['HTTP_USER_AGENT'], "MSIE") )
{
print 'Stai usando Internet Explorer';
}
else
{
print 'Non stai usando Internet Explorer';
}
?>
In poche parole la funzione strstr cerca nella variabile, la presenza del testo che gli abbiamo specificato, in questo caso MSIE e se lo trova risponde true. Quindi il controllo if risponde di conseguenza "Stai usando Internet Explorer" se la trova, altrimenti "Non stai usando Internet Explorer".
Effettuare il redirect con Php
Per motivi di logistica o di organizzazzione alle volte può essere necessario spostare un file da una posizione sul server ad un' altra. Per evitare di ritrovarsi con collegamenti interrotti e perdita di posizioni nei motori di ricerca si ricorre al redirect (reindirizzamento).
Questo argomento è stato già trattato in precedenza per due linguaggi: Html (Meta-tag) e Javascript.
Supponiamo di disporre della pagina "guestbook.php" inizialmente collocata nella root del sito, e di volerla trasferire nella cartella "guestbook".
Sarà innanzitutto necessario creare la pagina "guestbook/guestbook.php" per il corretto funzionamento del guestbook nella sua nuova posizione sul server, nonchè rimpiazzare il codice di "guestbook.php" (quello nella root) con questo:
<?php
header("Location: guestbook/guestbook.php");
?>
Tanto per spiegarmi meglio avremo due file adesso (e non più uno):
* guestbook.php (che punta al nuovo guestbook grazie al redirect);
* guestbook/guestbook.php (il nuovo guestbook).
Inserire data e ora in una pagina web
Inserire la data e l'orario del server nelle proprie pagine web è facilissimo.
Basta solo incollare queste righe di codice php:
Per la data:
<?php print (date ("d/m/Y")); ?>
Per l'ora:
<?php print (date ("H:i:s")); ?>
Quindi, con un po di ingegno potremmo avere, per esempio:
Sono le ore <?php print (date ("H:i:s")); ?> del <?php print (date ("d/m/Y")); ?>
Per ottenere la data in altri formati, cambiate i caratteri nella sintassi del codice.
a - "am" o "pm"
A - "AM" o "PM"
d - giorno del mese a 2 cifre (con lo zero, eventualmente), da "01" a "31"
D - giorno della settimana in inglese a tre lettere
F - mese in forma estesa in inglese
h - ora in formato 12 ore
H - ora in formato 24 ore
g - ora in formato 12 ore (senza lo zero), da "1" a "12"
G - ora in formato 24 ore (senza lo zero), da "0" a "23"
i - minuti (con lo zero, eventualmente), da "00" a "59"
j - giorno del mese a 2 cifre (senza lo zero), da "1" a "31"
l - giorno della settimana in inglese; es. "Friday"
m - mese a 2 cifre (con lo zero, eventualmente), da "01" a "12"
n - mese a 2 cifre (senza lo zero), da "1" a "12"
M - mese in inglese a tre lettere
s - secondi a 2 cifre (con lo zero, eventualmente), da "00" a "59"
S - suffiso ordinale inglese
t - numero di giorni del mese specificato, da "28" a "31"
w - giorno della settimana espresso come numero, da "0" (Domenica) a "6" (Sabato)
Y - anno a 4 cifre
y - anno a 2 cifre
z - giorno dall'inizio dell'anno
Recuperare la dimensione di un file
Il php ci mette a disposizione un comando per ricavare la dimensione in byte di un file presente sul server.
Il comando da eseguire ? il seguente:
$dimensione = filesize("nomedelfile.xxx");
Pertanto, supponiamo di voler calcolare il peso del nostro file index.php... il codice sar? il seguente:
<?php
echo ("Il file pesa ");
//recupero la dimensione del file in byte
$dimensione = filesize("index.php");
echo ($dimensione);
echo (" byte, pari a ");
//converto da byte a kilobyte
$dimensioneinkb = ($dimensione / 1024) ;
echo ($dimensioneinkb);
echo (" kb.");
?>
La riga $dimensioneinkb = ($dimensione / 1024) ; serve a convertire la grandezza da byte a kilobyte (1 kb = 1024 byte).
Realizzare un sito facilmente aggiornabile
Qui di seguito vedremo come realizzare un sito in PHP. In dettaglio vedremo le tecniche da utilizzare per un sito web facilmente aggiornabile.
Supponiamo di avere un sito con un header superiore, un corpo centrale ed un footer inferiore.
Inserendo in ogni pagina il codice di header, footer e corpo centrale, l'aggiornamento risulterebbe assai difficoltoso e lento. Ci serviremo quindi del comando include() di PHP, che permette di richiamare più files in altri.
Creiamo un file "header.php" ed inseriamoci questo codice:
<div id="header">
Qui tutto il codice dell'header...
</div>
Da notare come in questo file non siamo presenti i tags HTML o BODY.
Ora creiamo "footer.php":
<div id="footer">
Qui tutto il codice del footer
</div>
Quindi "index.php":
<!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=iso-8859-1" />
<title>Il mio sito con PHP</title>
</head>
<body>

<?php include("header.php"); ?>


<div id="corpo">
Qui il codice della pagina
</div>


<?php include("footer.php"); ?>

</body>
</html>
Da notare come il codice di header e footer venga richiamato in ogni pagina, di modo che sia possibile modificarlo nei rispettivi file e rendere effettive le modifiche in tutte le pagine del sito.
Possiamo ora personalizzare la grafica dei tre DIV con i CSS. Sicuramente un passo in avanti nella realizzazione di un sito web.
Creare un RSS con PHP e MySql
RSS, o Rich Site Summary ormai si sta diffondendo a macchia d'olio su tutto il web.
Il segreto del suo successo sta nel fatto che RSS è veloce e semplice allo stesso tempo.
In questo tutorial è descritto come creare e ad aggiornare il feed RSS automaticamente utilizzando PHP.
Il database
Creiamo la tabella news nel nostro database mysql
CREATE TABLE news (id int PRIMARY KEY AUTO_INCREMENT,
title varchar(255),
content text);
Iniziamo a riempire qualche campo di esempio
INSERT INTO news VALUES ('', 'test', 'test content');
INSERT INTO news VALUES ('', 'test2', 'more content');
Questa è la struttura del file RSS che dobbiamo ricreare.
<?xml version="1.0"?>
<rss version="2.0">
<channel>
<title>TagTagWeb</title>
<link>http://www.tagtagweb.com</link>
<description>Feed </description>
<language>it</language>
<item>
<title>Titolo 1</title>
<link>http://www.yoururlhere.com/1</link>
<description>Contenuto 1</description>
</item>
<item>
<title>Titolo 2</title>
<link>http://www.yoururlhere.com/2</link>
<description>Contenuto 2</description>
</item>
</channel>
</rss>
Script Php
La prima cosa da fare è recuperare i dati presenti sul database
<?php
$connection = mysql_connect("localhost", "username", "password");
mysql_select_db("database", $connection);
$select = "SELECT * FROM news ORDER BY id DESC LIMIT 5";
$query = mysql_query($select) or die(mysql_error());
?>
Abbiamo chiesto al database di restituirci al massimo 5 righe ordinate dal più recente al più vecchio
Iniziamo adesso a scrivere il file:
<?
$file = fopen("rss.xml", "w");
fwrite($file, "<?xml version="1.0"?>
<rss version="2.0">
<channel>
<title>TagTagWeb Feed</title>
<link>http://www.tagtagweb.com</link>
<description>Feed </description>
<language>it</language>");
//cicliamo sugli elementi ricavati da db e scriviamo gli items
while($array = mysql_fetch_array($query)){
extract($array);
$content = htmlentities($content);
fwrite($file, "<item>
<title>$title</title>
<link>http://www.tagtagweb.com/index.php?blog=post&id=$id</link>
<description>$content</description>
</item>");
}
fwrite($file, "</channel></rss>");
fclose($file);
?>
In questo caso abbiamo creato un file rss.xml, è possibile inoltre creare RSS al volo e far visualizzare all'utente il contenuto xml direttamente sul browser.
Il procedimento è simile cambiano solamente alcuni accorgimenti:
<?php
$connection = mysql_connect("localhost", "username", "password");
mysql_select_db("database", $connection);
$select = "SELECT * FROM news ORDER BY id DESC LIMIT 5";
$query = mysql_query($select) or die(mysql_error());
header("Content-type: text/xml"); //riga importate per far apparire l'xml nel browser
//scrivo direttamente sul documento
echo "<?xml version="1.0"?>
<rss version="2.0">
<channel>
<title>TagTagWeb RSS</title>
<link>http://www.tagtagweb.com</link>
<description>Feed</description>
<language>it</language>";
while($array = mysql_fetch_array($query)){
extract($array);
$content = str_replace("<br />", "\n", $content);
$content = htmlentities($content);
$content = str_replace("&", "&", $content);
echo "<item>
<title>$title</title>
<link>http://www.tagtagweb.com/index.php?blog=post&id=$id</link>
<description>$content</description>
</item>";
}
echo "</channel></rss>";
?>
=======================================================================
Creare feed Rss con PHP e MySQL
In questo tutorial ci occuperemo della realizzazione di un sistema PHP e MySQL in grado di gestire in automatico un feed rss.
In particolare gestiremo la tabella MySQL "News", composta da tre campi:
- ID
- TITOLO
- DESCRIZIONE
Ciò che il nostro sistema dovrà fare sarà connettersi al database MySQL, quindi selezionare la tabella "news", estrapolare i dati e visualizzare le ultime news come elementi RSS.
Creiamo un nuovo file e chiamiamolo "rss.php":
<?php
// Eseguo le operazioni di connessione al database MySQL
$connessione = mysql_connect("localhost", "username", "password");
mysql_select_db("nomedatabase", $connessione);
$selezionedati = "SELECT * FROM news ORDER BY ID DESC LIMIT 10";
$query = mysql_query($selezionedati) or die(mysql_error());
// Modifico l'intestazione e il tipo di documento da PHP a XML
header("Content-type: text/xml");
// Eseguo le operazioni di scrittura sul file
echo ("<rss version=\"2.0\">");
echo ("<channel>");
echo ("<title>Nome del FEED </title>");
echo("<link>http://www.miosito.com</link>");
echo ("<description>Una descrizione del FEED e del mio sito</description>");
echo "<copyright>Copyright 2006 Mio sito.com </copyright>\n";
echo "<docs>http://blogs.law.harvard.edu/tech/rss</docs>\n";
echo "<managingEditor>miamail@miosito.com</managingEditor>\n";
echo "<webMaster>miamail@miosito.com</webMaster>\n";
echo ("<language>IT-it</language>");
while($array = mysql_fetch_array($query)){
extract($array);
echo "<item>
<title>$TITOLO</title>
<link>http://www.miosito.com/leggi.php?ID=$ID</link>
<description>$DESCRIZIONE</description>
</item>";
}
echo "</channel></rss>";
?>
Alcune considerazioni
Sebbene il codice sia sufficientemente commentato, sono necessarie alcune considerazioni.
Si notino innanzitutto le righe:
// Eseguo le operazioni di scrittura sul file
echo ("<rss version=\"2.0\">");
echo ("<channel>");
echo ("<title>Nome del FEED </title>");
echo("<link>http://www.miosito.com</link>");
echo ("<description>Una descrizione del FEED e del mio sito</description>");
echo "<copyright>Copyright 2006 Mio sito.com </copyright>\n";
echo "<docs>http://blogs.law.harvard.edu/tech/rss</docs>\n";
echo "<managingEditor>miamail@miosito.com</managingEditor>\n";
echo "<webMaster>miamail@miosito.com</webMaster>\n";
echo ("<language>IT-it</language>");
in cui dovremo inserire le informazioni del nostro FEED e quindi del nostro sito web.
Alcuni di questi elementi sono facoltativi, ma è buona abitudine inserirli comunque.
Particolare attenzione al codice
while($array = mysql_fetch_array($query)){
extract($array);
echo "<item>
<title>$TITOLO</title>
<link>http://www.miosito.com/leggi.php?ID=$ID</link>
<description>$DESCRIZIONE</description>
</item>";
}
in cui lo script effettua il ciclo di visualizzazione dei vari records.
Ogni elemento di un file RSS è contenuto nel TAG "ITEM", e possiede tre sub-elementi:
- title
- link
- description
Come titolo, lo script manda a video il corrispondente testo presente nel campo TITOLO della tabella a livello del record selezionato.
Come description, lo script manda a video il rispettivo testo presente nel campo DESCRIPTION della tabella a livello del record selezionato.
Per quanto riguarda il sub-elemento LINK:
<link>http://www.miosito.com/leggi.php?ID=$ID</link>
da notare il fatto che si presuppone nel nostro sito esista una pagina LEGGI.PHP che in base all'ID digitato, visualizza i dati di una news particolare. Si tratta sostanzialmente di una semplice pagina di visualizzazione delle news.
Lo script visualizza l'ID corrispondente al record selezionato per ogni elemento ITEM.
=======================================================================
Creare un feed RSS 2.0 in 6 passi
Come creare un feed RSS 2.0
Se siete in grado di imparare l’HTML, allora potete facilmente imparare a creare un feed RSS 2.0. In questo articolo vi accompagnerò passo passo nella creazione di un feed RSS partendo da zero.
Passo 1: Dichiarazione XML
Visto che RSS 2.0 deve essere un documento XML valido, la prima riga nel vostro feed rss deve essere la dichiarazione XML.
< ?xml version="1.0" encoding="utf-8"?>
L’encoding è opzionale ma raccomandato. Se state usando qualcosa di diverso da UTF-8, ricordatevi di cambiare la riga in accordo con il set di caratteri che utilizzate.
Passo 2: Canale RSS
In questo passo dobbiamo aprire il tag rss, e il tag channel. Tutto il contenuto del vostro feed andrà dantro a questi tag.
Passo 3: Informazioni del Feed RSS
Successivamente dovete inserire le informazioni che riguardano il vostro feed, tipo il titolo (spesso è uguale alnome del sito di orgine), la descrizione, e un link al sito a cui si riferisce.
Importante è il tag language, dove è importante specificare il codice della lingua in cui è scritto il feed. Nel nostro caso sarà it-it, ma potrebbe essere us-en, per esempio se il contenuto è in inglese
http://www.esempio.it/
Questa è la descrizione del mio feed
Mon, 12 Sep 2005 18:37:00 GMT
it-it
Il tag lastBuildDate dovrebbe indicare la date e l’ora dell’ultima modifica del feed. Le date nei feed RSS dovrebbero aderire al documento RFC 822.
Anche se il tag lastBuildDate non è obbligatorio è altamente consigliato inserirlo.
Passo 4: “Items” RSS
I contenuti del nostro feed sono elencati negli “item” (elemento) di ogni feed. Ogni Item ha un titolo, link, descrizione, data di pubblicazione e guid (un identificatore univoco di questo elemento).
http://esempio.it/item/123
http://esempio.it/item/123
Mon, 12 Sep 2005 18:37:00 GMT
[CDATA[ Questa è la descrizione. ]]
Assicuratevi di convertire ogni carattere che potrebbe causare la mancata validazione dell’XML, questi caratteri includono < , >, & - . E’ buona norma includere tutto il contenuto che potrebbe essere formattato in HTML in una sezione CDATA.
Passo 5: Chiusura del tag Channel e RSS.
Passo 6: Convalidate il Feed
Verificate la validità del vostro nuovo feed usando FeedValidator.org.
Altre cose di cui tener nota:
* Categorie – E’ una buona idea includere anche il tag category nel vostro feed RSS, questo va all’interno del tag item. Potete dare ad ogni item molteplici categorie, basta includere più elementi category.
* Questo è solo una micro introduzione a quello che si può fare con un feed RSS, vi rccomando di leggere le specifiche RSS 2.0 per maggiori informazioni.
http://digitaldivide.garuti.it/2005/10/12/creare-un-feed-rss-20-in-6-passi/
Visualizzare un'immagine... solo se il campo di un database non è vuoto
In molte applicazioni web, specie nei guestbook e nei forum notiamo come alcuni utenti hanno, a fianco del loro username, il disegno di una casetta linkata alla propria home page e altri utenti no! La spiegazione è semplice: l'utente con la cesetta ha un sito web, quello senza no! La risposta è banalissima... ma non è questo che volevo spiegarvi :)
Vediamo la parte pratica. Chi ha avuto a che fare con un'applicazione simile saprà che è impossibile (senza adottare lo script che spiegherò tra un po') scegliere di visualizzare l'immagine se il campo del database è pieno o di non visualizzarla se questo è vuoto!
Creiamo pertanto uno script ad hoc per le nostre esigenze, supponendo di avere a che fare con un database (lascio a voi il compito della connessione) che dispone del campo 'sitoweb' e di avere accesso ai dati grazie al recorset 'dati_utente':
<?php
$sitoweb = $row_dati_utente['sitoweb']; //la variabile sitoweb corrisponde al campo sitoweb del database
if ($row_dati_utente['sitoweb'] != "")
{
//se questa variabile non è vuota stampo la casetta con il collegamento
echo "<a href=\"http://$sitoweb\"><img src=\"/images/home.jpg\" alt=\"Visita il sito dell'autore\" width=\"17\" height=\"17\" target=\"blank\" border=\"0\" /></a>";
}
else
{
echo ""; //altrimenti non visualizzo niente
}
?>
Come potete capire abbiamo innanzitutto stabilito che la variabile '$sitoweb' viene presa in input dal campo 'sitoweb' del database. In seguito abbiamo definito che se il campo 'sitoweb' non è vuoto viene stampata l'immagine della casetta (/images/home.jpg) con il link alla home page; in caso contrario non viene stampato niente.
L'html relativo all'inserimento dell'immagine linkata è stato creato grazie al comando echo di php. Abbiamo dovuto pertanto usare le cosiddette sequenze di escape scrivendo \" al posto delle sole " (virgolette).
Più difficile a dirsi che a farsi!
Invio e-mail
In questo tutorial vedremo come inviare e-mail dal web, con dei moduli a piacere con il PHP.
Creiamo la pagina contenete il modulo, "modulo.htm". Ecco il codice del form, da inserire tra i tags BODY:
Codice
<form method="post" action="inviamail.php" name="inviamail">
Nome:
<input type="text" size="40" name="nome">
E-mail:
<input type="text" size="40" name="email">
Oggetto:
<input type="text" size="40" name="oggetto">
Messaggio:
<textarea cols="50" rows="10" name="messaggio"></textarea>
<input type="submit" value="Invia"><input type="reset" value="Cancella">
</form>
Ora creiamo "inviamail.php". Essa conterrà le istruzioni PHP per inviare la mail ad indirizzo a piacere. Ecco il codice:
<?php
$indirizzo="tuamail@dominio.it";
{
mail($indirizzo,"Messaggio da parte di $nome: $oggetto","$nome - $email ha inviato il seguente messaggio:","$messaggio");
echo ("Il messaggio è stato inviato con successo ");
}
?>
<p><a href="http://www.sito.com">Torna al sito</a></p>
Ed ecco che, una volta impostata la variabile $indirizzo con il vostro indirizzo e-mail, lo script vi invierà tutti i contatti effettuati con il form della pagina "modulo.htm".

Inviare mail da un form: la funzione mail()
In questa lezione vediamo come creare un modulo html capace di spedire e-mail tramite il php.
Nel nostro caso creeremo il codice necessario per permettere all'utente di inviarci un'email compilando un semplice form sul nostro sito web!
Così facendo nascondiamo anche il nostro indirizzo agli occhi di eventuali spammer! Procediamo subito con la creazione delle due pagine... vediamo la prima modulo.htm
<form action="send_mail.php" method="post" name="mail" id="mail">
<table width="80%" border="0" align="center" cellpadding="0" cellspacing="0">
<tr>
<td><div align="center">Inserisci l'indirizzo presso il quale ricontattarti</div></td>
</tr>
<tr>
<td><div align="center">
<input name="indirizzo" type="text" id="indirizzo" size="40" maxlength="60">
</div></td>
</tr>
<tr>
<td> </td>
</tr>
<tr>
<td><div align="center">Oggetto del messaggio:</div></td>
</tr>
<tr>
<td><div align="center">
<input name="oggetto" type="text" id="oggetto" size="40" maxlength="50">
</div></td>
</tr>
<tr>
<td> </td>
</tr>
<tr>
<td><div align="center">Corpo del messaggio: </div></td>
</tr>
<tr>
<td><div align="center">
<textarea name="corpo" cols="40" rows="7" id="corpo"></textarea>
</div></td>
</tr>
<tr>
<td><div align="center">
<input type="submit" name="Submit" value="Invia">
<input type="reset" name="Submit2" value="Pulisci">
</div></td>
</tr>
</table>
</form>
Ora passiamo alla pagina send_mail.php che recupererà i dati dal form e li invierà tramite e-mail all'indirizzo specificato!
<?php
$mail_mittente = $_POST['indirizzo'];
$mail_destinatario = "michele@sassi.it"; //e-mail a cui saranno inviati i messaggi
$mail_oggetto = $_POST['oggetto'];
$mail_corpo = $_POST['corpo'];
if (mail($mail_destinatario, $mail_oggetto, $mail_corpo, "From: $mail_mittente"))
{
echo "E-mail inviata con successo";
}
else
{
echo "Errore... Non è stato possibile inviare alcun messaggio.";
}
?>
Personalizzate voi la grafica del vostro form, non posso pensare a tutto io ;)
Attenzione però perchè questa operazione non va a buon fine se il nostro server è temporaneamente fuori servizio o se non dispone del SendMail.
Creare un circuito banners in PHP
In questo tutorial vedremo come realizzare un semplice circuito di rotazione banner in PHP.
Supponiamo di voler far ruotare 3 banners, e di non disporre di database MySQL per memorizzare le informazioni dei singoli banners.
La pagina in cui ruotano i nostri banners si chiamerà "circuito.php".
Tramite la funzione random genero un numero a caso compreso tra 1 e 3, quindi lo controllo con un ciclo SWITCH (il migliore in questo caso) e infine, in base al numero visualizzo un banner.
Ecco il codice da inserire all'inizio della pagina prima dei TAGs HTML:
<?
// Genero il numero casuale
$numero = rand(1,3);
// Ciclo SWITCH con tanti casi quanti sono i banners
switch($numero)
{
// Primo banner
case "1":
$img = "banner1.gif";
$link = "http://www.link1.it";
break;
// Secondo banner
case "2":
$img = "banner2.gif";
$link = "http://www.link2.it";
break;
// Terzo banner
case "3":
$img = "banner3.gif";
$link = "http://www.link3.it";
break;
}
?>
Ed ecco ora il codice da inserire nel punto in cui si vuole visualizzare il banner:
<?php
// Visualizzo il banner
echo ("<a href='$link' target='_blank'><img src='$img' border='0'></a>");
?>
Potremmo inserire il primo codice in un file a parte del tipo "cod.php" e richiamarlo con un include() nei vari files in cui deve comparire il banner...
Aggiungiamo MySQL
E' possibile far sì che le informazioni riguardo ai banners siano prelevate da MySQL.
Supponiamo di avere una tabella "banners" con tre campi:
- id, di tipo INT - chiave primaria - AUTO INCREMENT
- img, di tipo TEXT
- link, di tipo TEXT
La selezione del banner avverrebbe in base all'ID:
<?
// Genero il numero casuale
$numero = rand(1,3);
// Genero il codice MySQL per la selezione
$query = mysql_query("SELECT * FROM banners WHERE id = '$numero'");
// Quindi assegno i risultati
$img = $row_query['img'];
$link = $row_query['link'];
?>
Il processo di visualizzazione è il medesimo del primo esempio.
Creiamo un Photoblog con PHP e MySQL
Pixelpost (http://www.pixelpost.org/), un photoblog basato su un motore scritto in PHP e MySQL, usa correttamente XHTML e CSS tutto documentato e modificabile con grande semplicità.
Requisiti
* Spazio web sufficiente: non per il software in se (circa 400 KB), ma per le immagini
* Apache Webserver o Windows IIS
* PHP, versione 4.3.0 o superiore
* PHP con GD-lib con JPG-support. (richiesto per la corretta visualizzazione delle thumbnails)
* MySQL versione 3.24.58 o superiore
* Un database MySQL funzionante
Scarichiamo il file pixelpost:
http://www.pixelpost.org/releases/pixelpost_1.4.3.zip
Editare il file pixelpost.php
Attraverso il vostro editor di testo preferito, aprite pixelpost.php che potete trovare dentro la cartella /includes e modificate le seguenti righe:
// host del vostro database, spesso "localhost"
$pixelpost_db_host = "localhost";
// utente del vostro database
$pixelpost_db_user = "inserite utente qui";
// password del vostro database
$pixelpost_db_pass = "inserite password qui";
// nome del database
$pixelpost_db_pixelpost = "inserite nome qui";
Upload
Caricate sul vostro server la cartella precedentemente decompressa.
Create la cartella per le immagini e per le thumbnails (anteprime)
Attraverso il vostro client FTP, create dentro la cartella pixelpost (a livello della radice) le seguenti cartelle:
images/
thumbnails/
e date loro i seguenti privilegi: lettura (7), scrittura (7) ed esecuzione (7) in modo che pixelpost possa salvare all'interno delle cartelle le vostre immagini.
Eseguiamo install.php
E' arrivata l'ora di installare pixelpost, basta aprire il proprio browser andando al seguente link, naturalmente cambiandolo opportunamente:
http://www.nomesito.com/cartella_pixelpost/admin/install.php
Apparirà, (se tutto è andato bene), una semplice schermata che vi guiderà in pochi passi alla corretta installazione del software.
Visualizzate il vostro photoblog
Ora non vi resta che visualizzare il vostro sito, ovvero, similmente al passo precedente andando su:
http://www.nomesito.com/cartella_pixelpost/.
Personalizzazione
Pixelpost è facilmente modificabile in tutte le sue componenti.
Potete modificare il suo motore, poichè scritto in PHP e completamente open source. Pixelpost gode di una folta schiera di seguaci, sviluppatori che hanno scelto questo software per il proprio blog e quindi lo migliorano.
Potete scaricare i così detti addons (http://www.pixelpost.org/v1/index.php?x=downloads&page=addon). Non sono altro che modifiche al motore di PHP che ne migliorano le potenzialità in molti aspetti.
Potete modificare l'aspetto finale, scaricando diversi templates (http://www.pixelpost.org/v1/index.php?x=downloads&page=template) messi a disposizione direttamente sul sito. Scaricateli, sono spesso in formato .zip, decomprimeteli e posizionateli sul vostro server dentro la cartella templates/.
Naturalmente, l'aspetto vero e proprio del blog si basa su CSS quindi potete andare a modificare lo stile.css presente all'interno delle cartelle dei vari templates.
Applicazione in Php per gestire facilmente una newsletter
Piccola, facile da configurare e funzionante senza bisogno di alcun database.
E' OpenNewsletter (http://www.selfexile.com/projects/opennewsletter), un set di script php che consente a chiunque di poter gestire una newsletter facilmente.
Basta avere un webserver con supporto a php, caricare la cartella contenentegli script di OpenNewsletter e il gioco è fatto.
Gli indirizzi di chi sottoscrive la newsletter vengono archiviati nel file di testo 'subscribers.txt'.
Certo le possibilità offerte in fase di composizione della newsletter sono limitate ma non si può volere tutto in 60Kb.
Per chi volesse dare un'occhiata a OpenNewsletter è disponibile una
demo online (http://www.selfexile.com/projects/opennewsletter/demo)
Utilizzare MySQL con PHP
Questa tecnologia mette a disposizione numerose funzioni per la connessione con MySQL, tutte presenti nel manuale ufficiale di questo linguaggio. Le principali funzioni sono:
* $Connessione=mysql_connect($server,$user,$password);
- E' la funzione che permette di accedere a MySQL. Come primo parametro inseriremo il nome del server, notoriamente ?localhost?; come nome utente ?root? che è l'utente di default e come password ?aspitalia? se si è seguito l'esempio in questo articolo.
* $database=mysql_select_db($name_db,$connessione);
- Con questa funzione selezioniamo direttamente il database di MySQL da utilizzare presente, ?esempio? nel nostro caso o qualsiasi altro presente visibile dalla shell di MySQL con il comando: ?show databasese;?. Il secondo parametro è la connessione precedentemente aperta verso il server.
* $tutto=mysql_query($sql,$connessione);
- Con questa funzione effettuiamo la query. Il primo parametro è una stringa contente i comandi SQL (?select?,?update?,?insert?,?delete?); il secondo parametro è la connessione aperta inizialmente.
* Mysql_free_result($tutto);
- Libera la memoria e le risorse del computer dalla query effettuata.
* Mysql_close($connessione);
- Chiude la connessione con MySQL.
* cols=mysql_num_fields($tutto);
- Questa funzione restituisce il numero di campi della query ?select? memorizzata in $tutto.
* rows=mysql_num_rows($tutto);
- Questa funzione restituisce il numero di record della query ?select? memorizzata in $tutto.
Creare un circuito banners in PHP
Supponiamo di voler far ruotare 3 banners, e di non disporre di database MySQL per memorizzare le informazioni dei singoli banners.
La pagina in cui ruotano i nostri banners si chiamerà "circuito.php".
Tramite la funzione random genero un numero a caso compreso tra 1 e 3, quindi lo controllo con un ciclo SWITCH (il migliore in questo caso) e infine, in base al numero visualizzo un banner.
Ecco il codice da inserire all'inizio della pagina prima dei TAGs HTML:
<?
// Genero il numero casuale
$numero = rand(1,3);
// Ciclo SWITCH con tanti casi quanti sono i banners
switch($numero)
{
// Primo banner
case "1":
$img = "banner1.gif";
$link = "http://www.link1.it";
break;
// Secondo banner
case "2":
$img = "banner2.gif";
$link = "http://www.link2.it";
break;
// Terzo banner
case "3":
$img = "banner3.gif";
$link = "http://www.link3.it";
break;
}
?>
Ed ecco ora il codice da inserire nel punto in cui si vuole visualizzare il banner:
<?php
// Visualizzo il banner
echo ("<a href='$link' target='_blank'><img src='$img' border='0'></a>");
?>
Potremmo inserire il primo codice in un file a parte del tipo "cod.php" e richiamarlo con un include() nei vari files in cui deve comparire il banner...
Aggiungiamo MySQL..
E' possibile far sì che le informazioni riguardo ai banners siano prelevate da MySQL.
Supponiamo di avere una tabella "banners" con tre campi:
- id, di tipo INT - chiave primaria - AUTO INCREMENT
- img, di tipo TEXT
- link, di tipo TEXT
La selezione del banner avverrebbe in base all'ID:
<?
// Genero il numero casuale
$numero = rand(1,3);
// Genero il codice MySQL per la selezione
$query = mysql_query("SELECT * FROM banners WHERE id = '$numero'");
// Quindi assegno i risultati
$img = $row_query['img'];
$link = $row_query['link'];
?>
Il processo di visualizzazione è il medesimo del primo esempio.
Un completo AdServer con PHP
Ciao a tutti, in questo articolo vedremo come creare un sistema di rotazione banner (AdServer).
Cominciamo come al solito con il creare il file di configurazione (config.php) che ci servirà per configurare e per connettersi a MySQL.
Ecco il codice da inserire nel file:
<?php
$mysql['host'] = "";
$mysql['pass'] = "";
$mysql['user'] = "";
$mysql['name'] = "";
@mysql_connect($mysql['host'], $mysql['user'], $mysql['pass']);
@mysql_select_db($mysql['name']);
?>
In questo file, si nota il fatto che è presente una sola variabile, $mysql, che, in questo caso svolge la funzione di array().
E poi ci sono due funzioni, mysql_connect() e mysql_select_db(), che sono presenti nel PHP dalla versione 3 (compresa) in poi.
Ovviamente ora creiamo anche il file di installazione, install.php:
<?php
require("config.php");
@mysql_query("CREATE TABLE 'ads' (
'id' INT( 11 ) NOT NULL ,
'nome' VARCHAR( 255 ) NOT NULL ,
'banner' VARCHAR( 255 ) NOT NULL ,
'url' VARCHAR( 255 ) NOT NULL ,
'view' VARCHAR( 255 ) DEFAULT '0' NOT NULL ,
'click' VARCHAR( 255 ) DEFAULT '0' NOT NULL ,
PRIMARY KEY ( 'id' )
);");
echo "Operazione avvenuta con successo !!\n";
@mysql_close();
?>
Quì c'è solamente una query che serve appunto per installare l'applicazione creando una tabella nel tuo database MySQL.
Assicurarsi che non ne esista già una con lo stesso nome!
Ovviamente sarà necessario inserire qualche banner per vedere come funziona il nostro AdServer.
Per farlo potete facilmente crearvi un pannello di controllo ad hoc (cercate negli altri tuotorial come inserire dati in un db MySql) oppure lavorare direttamente sul database, con un semplice scriptino del genere:
<?php
require("config.php");
$banner['name'] = "banner1";
$banner['img'] = "http://www.miosito/banner.jpg";
$banner['link'] = "http://www.miosito.com";
@mysql_query("insert into 'ads' value (
'',
'" . $banner['name'] . "',
'" . $banner['img'] . "',
'" . $banner['link'] . "',
'0',
'0'
);)";
echo "Banner aggiunto con successo !!\n";
@mysql_close();
?>
Vediamo ora come visualizzare i nostri banner in modo random (casuale)... ovviamente se abbiamo inserito un solo banner nel nostro DB vedremo semppre quello!
Creiamo una nuova pagina e salviamola come view.php, ecco il codice da inserire:
<?php
require("config.php");
$query = @mysql_query("SELECT * FROM ads ORDER BY RAND()");
$result = @mysql_fetch_array($query);
@mysql_query("UPDATE ads SET view = view+1 WHERE id = '$result[0]'");
echo "<a href=\"click.php?id=$result[0]\"><img border=\"0\" src=\"$result[2]\" alt=\"$result[1]\"></a>";
@mysql_close();
?>
Nel codice appena visto, notiamo due variabili: $query e $result, la prima serve per inviare il comando al database MySQL, ossia quello di prelevare un record a caso fra quelli inseriti, la seconda variabile invece ci serve per ricavare i vari risultati, vale a dire l'ID, l'immagine e il nome del banner.
In oltre, c'è anche un'altra query che viene inviata al database, ossia quella che serve per aumentare il numero di visualizzazioni del banner.
I vari risultati sono stati inseriti in una stringa HTML che ci serve per visualizzare il banner e per collgarlo alla pagina che conterà il numero dei click e che lo reindirizzerà alla l'url del banner stesso.
Vediamo ora la quarta e penultima pagina di questa applicazione.
Questa pagina si chiamerà click.php e conterrà questo codice:
<?php
require("config.php");
@mysql_query("UPDATE ads SET click = click+1 WHERE id = '$id'");
$query = @mysql_query("SELECT * FROM ads WHERE id = '$id'");
$result = @mysql_fetch_array($query);
header("Location: $result[3]");
@mysql_close();
?>
Vediamo un po' che dire riguardo a questo codice...
Una cosa salta agli occhi, che, ancora una volta sono presenti du query.
La prima query, svolge una funzione di UPDATE; o meglio... aumenta il numero di click nel banner che si è appena clickato.
Mentre la seconda, ancora una volta, invia una query per ricavare i dati dal database.
Questa volta, l'unico dato che ci interessa è la destinazione del banner, ossia il sito internet a cui si riferisce.
Infine vediamo come realizzare delle piccole statistiche.
Creiamo un file e salviamolo come stats.php ed inseriamoci questo codice:
<?php
require("config.php");
echo "<table width=\"38%\" border=\"0\" cellspacing=\"0\" cellpadding=\"2\">\n";
echo "<tr>\n";
echo "<td width=\"12%\"><strong>Nome</strong></td>\n";
echo "<td width=\"12%\"><strong>Visualizzazioni</strong></td>\n";
echo "<td width=\"12%\"><strong>Clicks</strong></td>\n";
echo "<td width=\"12%\"><strong>%</strong></td>\n";
echo "</tr>\n";
$query = @mysql_query("SELECT * FROM ads");
$totals = @mysql_query("SELECT * FROM ads");
while($res = @mysql_fetch_array($totals))
{
$total = $total + $res[4];
}
while($result = @mysql_fetch_array($query))
{
$percentuale = $result[4] / $total;
$percentuale = $percentuale * 100;
$percentuale = number_format($percentuale, 1);
echo "<tr>\n";
echo "<td>$result[1]</td>\n";
echo "<td>$result[4]</td>\n";
echo "<td>$result[5]</td>\n";
echo "<td>$percentuale%</td>\n";
echo "</tr>\n";
}
echo "</table>";
@mysql_close();
?>
Analiziamo un pochino questo codice...
Sulla prima parte del codice, c'è poco ad dire, è semplicemente l'inizio di una tabella che indica il conenuto delle sue colonne.
Subito dopo, troviamo due variabili, $query e $totals, che ci servono per inviare le query al database MySQL.
Nella parte di codice seguente troviamo due cicli while().
Il primo, che usa la variabile $totals, ci serve per sommare il numero delle visualizzazioni per poi creare la percentuale, il secondo per stampare a video il nome del banner, i click ricevuti e le visualizzazioni che sono state fatte con anche la percentuale.
Si nota comunque, che nel secondo ciclo viene fuori un'altra variabile, ossia $percentuale, la stessa serve appunto per creare la percentuale delle visualizzazioni di tutti i banner!
Scrivere i file con i form
Sempre ricordandoci di avere i permessi sul nostro file, noi possiamo scrivere su file da un form. Per esempio possiamo realizzare questo per tante cose però dobbiamo strare attenti perchè è un pò pericoloso. Ammettiamo che qualcuno scriva su un file qualche operazione php dannosa......Diciamo che si deve stare attenti a cosa lo usiamo. Ma non vi preoccupate la scrittura da form a file non la faremo per cose importanti infatti per quelle ci sono i database. Siccome c'e la scrittura nei file non posso mostrarvi l'esempio se no intaserei la mia cartella e non mi va nemmeno di crearne altre(si il mio serve mi da una cartella e li posso scrivere e leggere i miei file). Basta che copiate e incollate il codice nel bloc notes e salvate le pagine con il loro nome.
Pagina dove si possono inserire annunci nome : uno.htm (si nota come uso il marcatore   per fare gli spazi non è professionale ma dovevo fare in fretta
<html>
<body>
<center>
<form method=get action="verifica.php">
<br>Nome
<input type="text" name="nome" size="20">
<br>Recapito
<input type="text" name="recapito" size="20">
<p>Oggetto  
<br>   <textarea name="oggetto" rows="3" cols="40"></textarea> </p>
<br>
<input type="submit" value="Invia">
<input type="reset" value="Cancella">
</form>
</body>
</html>
Non vi sto a spiegare il modulo perchè semplice(un semplice modulo con tre campi)
Come si nota il pulsante invia mi porta ad una pagina chiamate verifica.php
<?php
echo "<center>";
echo "Ciao ecco i risultati del tuo inserimento:";
$errore= false;
If((!$nome) || (!$recapito) || (!$oggetto)) {
#controllo che nessun campo sia vuoto
$errore=true;
echo "Non hai compilato tutti i campi <a href=\"uno.htm\">torna indietro</a>";
exit;
}
else{
echo " i campi sono ok";
}
#controllo che il file sia accessibile
if (!$apri = fopen ("file.txt","a+")) {
$errore=true;
echo "non posso aprire il file";
}else{
$apriw = fopen ("file.txt","a+");
#ora creo una variabile che contiene la linea di reparazione
$linea ="<hr color=red>";
# e sul file scrivo nome e vado a capo,il recapito e vado a capo
# l'oggetto e vado a capo e la linea ti separazione
fputs($apriw,"$nome\n");
fputs($apriw,"$recapito\n");
fputs($apriw,"$oggetto\n");
fputs($apriw,"$linea");
#chiudo il file
fclose($apriw);
}
#se c'e l'errore mi dice di inserirli di nuovo altrimenti mi fa leggere gli annunci
if($errore){
echo"<br> Riinseriscili perfavore<br>";
}
else{
echo "<br> <a href=\"annunci.php\">leggi gli annunci</a>";
}
?>
Ecco la pagina che mi legge dal file chiamata annunci.php
<?php
echo "Ecco i vostri annunci<br>";
if (!$apri = fopen("file.txt","r")){
echo "Non posso aprire il file";
}else{
#Se il file si può leggere allora con un ciclo while
# leggo tutte le righe del mio file
while(!feof($apri)){
$leggo = fgets($apri,255);
echo "$leggo<br>";
}
}
fclose($apri);
?>
Come fare un sondaggio con php e mysql
3)scegli.htm
diamo un occhiatina veloce a questo file
<html>
<head>
<title>Sondaggio</title>
</head>
<body>
<form action="vai.php" method="post">
Italia<input type="radio" value="italia" name="paese"><br>
Spagna<input type="radio" value="spagna" name="paese"><br>
Portogallo<input type="radio" value="portogallo" name="paese"><br>
Francia<input type="radio" value="francia" name="paese"><br>
Inghilterra<input type="radio" value="inghilterra" name="paese"><br>
<input type="submit" value="VOTA">
</form>
</body>
</html>
Niente da spiegare qui un form semplice che punta a via.php con metodo post e usa il tipo radio passando il valore come nome
4)vai.php
Innanzitutto includo il file di connessione
PHP:
<?php
include("db_connect.php");
$risultati_mysql=mysql_query("SELECT * FROM nomi ");
while ($riga1=mysql_fetch_array($risultati_mysql))
{
$id=$riga1["$paese"];
$idnuovo=($id + 1);
}
$sql="UPDATE nomi SET $paese='$idnuovo' ";
if(!mysql_query($sql)){
echo "Errore impossibile votare";
echo "<script>
function redirect(){
window.location.replace(\"scegli.htm\");
}
setTimeout(\"redirect()\", 2000);
</script>";
exit();
}else{
echo "Voto valido";
echo "<script>
function redirect(){
window.location.replace(\"guarda.php\");
}
setTimeout(\"redirect()\", 2000);
</script>";
}
mysql_close();
?>
Ecco cosa faccio dopo essermi collegato a mysql dopo aver selezionato la nostra tabella sondaggi.
Faccio una query di selezione(mysql_query("SELECT * FROM nomi ")) e prendo tutta la tabella nomi. La inserisco in un array (mysql_fetch_array($risultati_mysql)
ed subito dopo in una variabile chiamata $id metto il valore della colonna chiamata $paese (che è il nome che passo tramite form selezionando il paese). Poi creo
una nuova variabile $idnuovo e gli assegno il valore della variabile $id +1 . Dopo aver fatto cio faccio UPDATE nomi SET $paese='$idnuovo' che praticamente modifica
il campo passato attraverso form con il nuovo valore. Dopidichè controllo che la query sia valida e nel caso sia errata lancio un javascript mandando l'utente alla pagia scegli.htm
altrimenti se la query e valida lo mando alla pagina guarda.php .
quote:
PHP:
$risultati_mysql=mysql_query("SELECT * FROM nomi ");
while ($riga1=mysql_fetch_array($risultati_mysql))
{
$id=$riga1["$paese"];
$idnuovo=($id + 1);
}
$sql="UPDATE nomi SET $paese='$idnuovo' ";
if(!mysql_query($sql)){
echo "Errore impossibile votare";
echo "<script>
function redirect(){
window.location.replace(\"scegli.htm\");
}
setTimeout(\"redirect()\", 2000);
</script>";
exit();
}
5)guarda.php
In questo file dovete avere dimestichezza con le operazioni matematiche....
Dopo aver incluso il file di connessione seleziono la tabella nomi e la metto in un array. Poi creo delle variabili che contengono ognuna i valori dei
campi di ogni squadra. Praticamente in ogni variabile ci sta il numero dei voti ottenuti. Quindi per vedere quanti voti in totale abbiamo facciamo la somma
delle variabili
$totale=$spagna+$italia+$portogallo+$francia+$inghilterra;
La somma a noi ci serve per due motivi: uno e che vogliamo mostrare agli utenti quante
persone fino ad ora hanno votato, l'altro dobbiamo fare la percentuale di ogni paese. Per fare la percentuale si fa (VOTI OTTENUTI) per 100 diviso (VOTI TOTALI).
$percspagna= $spagna*100/$totale; . Per avere un sondaggio piu pulito io arrotondo il risultato a due cifre dopo la virgola con $s=round($percspagna, 2); $s e la
variabile che contiene il nostro dato round e la funzione che arrotonda $percspagna e la percentuale e 2 sono le cifre massime dopo la virgola. Ora noi abbiamo
ottenuto la percentuale. Questa io la usero per due motivi come per il totale: uno per mostrare agli utenti quanta percentuale ha un campo l'altra la uso per dimensionare
la mia immagine. La percentuale che io ottengo non ha il simblo % dopo il numero quindi e solo un numero normale. Cioe se la spagna ha preso il 40% dei voti quando calcolo
la percentuale la variabile $s conterra 40 e non 40%. Questa precisazione va fatta perche quando inseriro il valore per mostrare la percentuale devo aggiunfere manualmente
il simbolo %. Quando devo mostrare la mia immagine è diverso perche modifico dinamicamente il width(GRAZIE BUBU BUBU). Se ho un immagine di 100px puo andare bene quella misura ma 100 px sono pochi. IO nel file
6)vota.gif ho una gif lunga 300 px. Allora per prendere le dimensioni della nostra barra che ogni paese avrà (il grafico che andremo a creare) moltiplico il numero che ottengo dalla
percentuale per 3.
Perche lo moltiplico per 3
E semplice : quanto ottengo la percentuale abbiamo detto prima che ottengo 40 e non 40%. Quindi la mia immagine avra di lunghezz 40 px(calcolo fatto su 100). La mia
immagine e 300 px quindi tre volte il valore con cui si calcola la percentuale. Come potete vedere sotto e molto chiaro lo schema e per mettere in ordine ho usato il tag pre
PHP:
<?php
include("db_connect.php");
$risultati_mysql=mysql_query("SELECT * FROM nomi ");
while ($riga1=mysql_fetch_array($risultati_mysql))
{
$spagna=$riga1["spagna"];
$italia=$riga1["italia"];
$portogallo=$riga1["portogallo"];
$francia=$riga1["francia"];
$inghilterra=$riga1["inghilterra"];
}
$totale=$spagna+$italia+$portogallo+$francia+$inghilterra;
echo "In totale ci sono $totale voti";
$percspagna= $spagna*100/$totale;
$s=round($percspagna, 2);
$percitalia= $italia*100/$totale;
$i=round($percitalia, 2);
$percfrancia= $francia*100/$totale;
$f=round($percfrancia, 2);
$percportogallo= $portogallo*100/$totale;
$p=round($percportogallo, 2);
$percin= $inghilterra*100/$totale;
$n=round($percin, 2);
//ora faccio il calcono della lunghezza dell immagine
$s1=$s*3;
$i1=$i*3;
$p1=$p*3;
$f1=$f*3;
$n1=$n*3;
echo "<pre>";
echo "Spagna <img src=\"vota.jpg\" height=10 width=$s1> $s%<br>";
echo "Italia <img src=\"vota.jpg\" height=10 width=$i1> $i%<br>";
echo "Portogallo <img src=\"vota.jpg\" height=10 width=$p1> $p%<br>";
echo "Francia <img src=\"vota.jpg\" height=10 width=$f1> $f%<br>";
echo "Inghilterra <img src=\"vota.jpg\" height=10 width=$n1> $n%<br>";
echo " </pre>";
mysql_close();
?>
Questa applicazione puo essere implementata in tanti modi per far si che non si posssa votare piu di 1 volta in un giorno.
Si puo fare con i cookie oppure memorizzando l'ip..
Io vi mostro con i cookie come si fa...
Prendete il file vai.php e subito dopo <?php mettete
PHP:
if($paese){
setcookie ("sondaggio","cookie impostato",time()+86400,"/");
}
if($sondaggio){
echo "Si puo votare solo una volta al giorno";
exit();
}
Cioè se si passa un valore con $paese(perche uno puo provare anche a non votare) si setta un cookie chiamato sondaggio. Poi basta
Controllare se c'e.....
Ricavare IP & Hostname con Php
Con Php è possibile ricavare l'indirizzo IP da un Hostname e viceversa.
Le funzioni che ci permettono di fare ciò sono:
* gethostbyaddr(), per ricavere l'Hostname
* gethostbyname(), per ricavere l'IP
Ecco il codice:
<?PHP
$from = $HTTP_GET_VARS["f"];
$query = $HTTP_GET_VARS["q"];
if ($query != "")
{
if ($from == "IP")
{
$host = gethostbyaddr($query);
echo "L'hostname di <em>".$query."</em> è <strong>".$host."</strong>.";
}
else if ($from == "Host")
{
$ip = gethostbyname($query);
echo "L'indirizzo IP di <em>".$query."</em> è <strong>".$ip."</strong>.";
}
else
{
exit("Errore!");
}
}
else
{
exit("Errore!");
}
?>
Motore di ricerca con PHP
Per inserire un motore di ricerca sfruttando il linguaggio PHP, utilizzeremo DGS Serach, un software molto veloce e semplice da installare, che consente di effettuare ricerche su pagine e su database(i database supportati sono MySQL, PostgreSQL, MSSQL e InterBase). Nell'ultima versione i risultati vengono restituiti in un'interfaccia simile al noto motore di ricerca Google.
Scarichiamo il file zip da questo indirizzo (http://www.webmasterpoint.org/php/tutorial/dgssearch.zip), e decomprimiamo l'archivio.
Apriamo il file config.php, e cominciamo a modificare le variabili.
$config['installBase'] = 'c:\\inetpub\\wwwroot\\dgssearch';
Il percorso in cui è installato DGS Serach
$config['searchModules'] = array('fs');
I moduli da utilizzare nella ricerca. fs corrisponde al file system, db al database
$config['displayModules'] = array('title', 'query', 'stats', 'hr', 'nav', 'results', 'nav');
Moduli da utilizzare per i risultati
$config['language'] = 'english';
Linguaggio da utilizzare: sono disponibili english, german e spanish
$config['header'] = 'header.php';
L'header
$config['footer'] = 'footer.php';
Il footer
$config['target'] = '_self';
Il target della pagina dei risultati
$config['fonts'] = 'Arial, Sans-Serif, Helvetica';
Il font
$config['results'] = 10;
Risultati per pagina
$config['urlBase'] = 'http://www.xyz.com';
L'url dl nostro sito
$config['siteBase'] = 'c:\\inetpub\\wwwroot';
La root
$config['fsExclude'] = array('^\.ht', '^dgssearch$');
I file o le cartelle da escludere dalla ricerca
$config['exts'] = array('s?html?', 'php3?', 'txt');
Le estensioni dei file da includere nella ricerca. Inserire '' per includerli tutti.
$database[0]['type'] = 'mysql';
Il tipo di database. E' possibile inserire mysql, pgsql, mssql, ibase o odbc.
$database[0]['server'] = 'localhost';
Indirizzo per connettersi al database
$database[0]['port'] = 0;
La posta del database. Settare su 0 per quella di default
$database[0]['username'] = 'username';
Username per collegarsi al database
$database[0]['password'] = 'password';
Password per collegarsi al database
$database[0]['database'] = 'database';
Il nome del database
$database[0]['persistent'] = true;
Definisce se la connessione al database dev'essere persistente
$database[0]['table'] = array('art');
Nome della tabella del database dove verrà effettuata la ricerca
$database[0]['searchField'] = array('title', 'artist');
Campi all'interno dei quali cercare
$database[0]['link'] = 'Title is @1@';
Link utilizzato per i risultati
$database[0]['url'] = 'http://www.xyz.com/bogus.php?id=@0@';
L'url usato per visualizzare i dati dal database
$database[0]['desc'] = array('The artists name is @2@.');
La descrizione che verrà mostrata
Adesso è sufficiente effettuare l'upload dei file sul server. In seguito colleghiamoci all'indirizzo http://www.nomesito.it/cartella_dove_si_trova_lo_script/index.php.
Adesso siamo pronti per utilizzare lo script.

Mostrare il numero degli utenti collegati al nostro sito
In tutta onestà, questo codice è molto più semplice di quanto uno possa pensare: lo script si collega a un database e aggiorna alcuni campi, dopodiché conta il numero degli utenti che sono online.
Diamo un'occhiata a come sono settate le tabelle per il database:
CREATE TABLE useronline (
timestamp int(15) DEFAULT '0' NOT NULL,
ip varchar(40) NOT NULL,
file varchar(100) NOT NULL,
PRIMARY KEY (timestamp),
KEY ip (ip),
KEY file (file)
);
"Timestamp" viene usato per mostrare il momento in cui un utente è entrato in una specifica pagina del vostro sito web.
In più, l'indirizzo IP di ogni utente viene annotato per assicurarsi che identiche entrate non vengano aggiunte al database.
Il campo "File" è semplicemente la funzione PHP_SELF che da il percorso dello script attualmente in esecuzione.
Sul mio computer è così: /llama/www/php/script.php
Non voglio entrare nei particolari per quanto riguarda gli ultimi 3 campi, è sufficiente sapere che servono per il controllo e l'affidabilità degli errori.
Diamo ora un'occhiata a come funziona il codice PHP con il database per rintracciare quanti utenti stanno visitando una particolare pagina del vostro sito web.
Ecco qui l'intero codice PHP.
Per prima cosa diamo un'occhiata all'intero script, dopodiché lo divideremo in sezioni che andremo a commentare.
<?php
$server = "xxx";
$db_user = "xxx";
$db_pass = "xxx";
$database = "xxx";
$timeoutseconds = 300;
$timestamp = time();
$timeout = $timestamp-$timeoutseconds;
mysql_connect($server, $db_user, $db_pass);
$insert = mysql_db_query($database, "INSERT INTO useronline VALUES ('$timestamp','$REMOTE_ADDR','$PHP_SELF')");
if(!($insert)) {
print "Useronline Insert Failed > ";
}
$delete = mysql_db_query($database, "DELETE FROM useronline WHERE timestamp<$timeout");
if(!($delete)) {
print "Useronline Delete Failed > ";
}
$result = mysql_db_query($database, "SELECT DISTINCT ip FROM useronline WHERE file='$PHP_SELF'");
if(!($result)) {
print "Useronline Select Error > ";
}
$user = mysql_num_rows($result);
mysql_close();
if($user == 1) {
print("<b>$user</b> user onlinen");
} else {
print("<b>$user</b> users onlinen");
}
?>
L'inizio dello script contiene solo semplici istruzioni che servono per collegarsi a MySQL, dovete sostituire "XXX" con i valori del vostro database.
Ora interessiamoci alla variabile $timeoutseconds = 300.
Questa variabile va a dare istruzioni riguardo al time out. Verrà usata più avanti nello script per cancellare gli utenti dopo che sono passati 300 secondi (5 minuti).
Ora esaminiamo questa parte di codice:
<?php
$insert = mysql_db_query($database, "INSERT INTO useronline VALUES ('$timestamp','$REMOTE_ADDR','$PHP_SELF')");
if(!($insert)) {
print "Useronline Insert Failed > ";
}
?>
Questo codice si connette semplicemente al vostro database e poi inserisce i valori nella tabella degli utenti online (useronline table)
La parte successiva del codice controlla il database e va a cancellare i record degli utenti sconessi (per esempio dopo che sono trascorsi i 300 secondi):
<?php
$delete = mysql_db_query($database, "DELETE FROM useronline WHERE timestamp<$timeout");
if(!($delete)) {
print "Useronline Delete Failed > ";
}
?>
Questa parte di codice è davvero molto utile e offre una tecnica molto accurata per tenere aggiornati i risultati.
Se questo metodo non venisse usato, avremmo una tabella che continuerebbe a crescere ogni volta che un utente accede alla pagina del sito e potrebbe così contenere molte centinaia di righe se avete un sito con un discreto numero di visite.
Ora diamo un'occhiata al codice qui sotto:
<?php
$result = mysql_db_query($database, "SELECT DISTINCT ip FROM useronline WHERE file='$PHP_SELF'");
if(!($result)) {
print "Useronline Select Error > ";
}
?>
Questa parte di codice seleziona l'indirizzo IP dal database e controlla in che pagina sta navigando l'utente (PHP_SELF).
Operiamo in questo modo per poter visualizzare il numero degli utenti online nella parte seguente dello script.
NOTA: Le dichiarazioni IF() che abbiamo incontrato in alcune parti del codice sono dichiarazionI di controllo dell'errore.
Il punto esclamativo (!) rappresenta semplicemente NON FOUND o NULL.
Continuiamo con il seguente codice:
<?php
$user = mysql_num_rows($result);
mysql_close();
if($user == 1) {
print("<b>$user</b> user onlinen");
} else {
print("<b>$user</b> users onlinen");
}
?>
La variabile $user conta semplicemente il numero delle righe nella tabella degli utenti online e questo andrà a rappresentare il numero degli utenti che sono online. Facile no?
Infine, il nostro codice PHP chiude la connessione a MySQL e poi mostra il numero degli utenti online usando la funzione "print".
Se c'è solo un utente online, l'output sarà così: "1 user online" (1 utente connesso), se invece ci saranno più utenti online, per esempio 5, l'output sarà "5 users online" (cinque utenti connessi).
Per coloro che scrivono script più avanzati, possiamo andare a sostituire il nostro blocco IF in questo modo:
<?php
print "$user user" . ($user == 1 ? "" : "s") . " online";
?>
Mostrare il numero di utenti online è un gran modo per far sapere alle gente che non sono da soli a navigare nel vostro sito web, ma ci possono essere anche degli inconvenienti: infatti se lo script contiene degli errori, la pagina non verrà caricata correttamente.
Inoltre, prima di utilizzare questo script, è bene assicurarsi che il nostro sito web abbia un traffico decente, sarebbe infatti inutile usarlo per un sito che ha solo un paio di visitatori al giorno.

Un visualizzatore di immagini in Php
In Php possiamo con un semplice codice e con un minimo di ingegno costruire piccole utility per il nostro sito, come il visualizzatore di immagini che esamineremo in questo Articolo.
Si crei il file viewer.php (attenzione, se volete rinominarlo dovete cambiare il nome del file anche nel codice in fase di creazione del menu di navigazione) ed eseguitelo sul vostro server dopo aver copiato il codice che segue:
<?PHP
$id = $_GET['id'];
$immagine = "";
if (is_numeric($id) == FALSE)
{
$immagine = "blank";
}
else
{
$immagine = $id;
}
?>
<h1 align="center">VISUALIZZATORE DI IMMAGINI</h1>
<p align="center">
<img src="<?print $immagine?>.jpg">
<br><br>
<?PHP
for ($i=1; $i<5; $i++)
{
print "[<a href='viewer.php?id=" . $i . "'>" . $i . "</a>] ";
}
?>
</p>
Il funzionamento è semplice: si crei il file blank.jpg che rappresenti un'immagine bianca, del colore di sfondo della vostra pagina o un simbolo a vostra scelta. Si prendano poi 4 file immagine con estensione .jpg e li si dispongano nella stessa cartella o posizione sul server.
Cliccando sul menu di navigazione verrà passata alla pagina una querystring che visualizzerà l'immagine di cui al numero cliccato. Per aggiungere immagini è necessario modificare il ciclo for inserendo il numero di immagini che avete a disposizione (+ 1); si consiglia di usare una numerazione crescente senza lasciare spazi tra i numeri (es. 1 2 3 5 6 7 dove manca il 4).
Grafici in HTML con PHP (da webmasterpoint.org)
Introduzione
Il linguaggio di scripting PHP può utilizzare la libreria grafica GD. E' sufficiente compilare PHP col supporto per GD (che deve essere installata prima ovviamente), oppure in alcune distribuzioni (ad es. la Mandrake 7.2) basta installare il pacchetto php-gd e sarete in grado di creare "dinamicamente" immagini in formato PNG da script PHP. In particolare con le primitive di questa libreria potete creare grafici di ottima fattura. Tuttavia per alcune semplici applicazioni, come quelle che descriverò in questo articolo, non è necessario ricorrere a GD: anche solo con l'utilizzo dell'HTML si possono produrre grafici a barre esteticamente belli. Di certo non potete disegnare grafici 3D o a torta, cosa che invece potete fare con la GD, tuttavia vale la pena lo stesso di esplorare questa possibilità.
Installazione di HTML_Graphs
Iniziate ad installare HTML_Graphs (dovrebbe essere una class di php) che è un pacchetto di funzioni per generare con facilità grafici in HTML, scritto da Phil Davis, ed è free software distribuito secondo la licenza GPL (GNU General Public License). L'installazione è molto semplice, basta scompattarlo al di sotto della document root. Ad es. nel mio PC con Linux la document root è /var/www/html/ e per scompattare i file zip utilizzo l'utility unzip. Per ordine ho deciso di porre tutti i file dentro la directory web "/HTML_Graphs":

# unzip HTML_Graphs.zip 
-d /var/www/html/HTML_Graphs

Per far funzionare l'esempio in un sistema UNIX, dove i nomi dei file sono case-sensitive, occorre che cambiate la riga

require("./html_graphs.php3");

in HTML_Graphs_Example.php3 (dovrebbe essere la linea 79) in:

require("./HTML_Graphs.php3");

o viceversa cambiate nome al file. Fatto questo con un browser andate all'URL:
http://localhost/HTML_Graphs/HTML_Graphs_Example.php3
Un esempio
Supponete di voler realizzare un semplice sondaggio online sul vostro sito, di quelli che vado molto di moda su alcuni portali ultimamente. Si tratta di porre ai visitatori una domanda con risposte multiple da scegliere. Volete che dopo aver votato il visitatore ritorni alla stessa pagina in cui però al posto del questionario appaiano le statistiche e che queste possano essere visionate anche senza dover votare tramite apposito link.
Ecco ad es. una domanda in cui si può dare una sola risposta:

Il codice HTML relativo è piuttosto semplice (il file l'ho chiamato index.php3):

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 3.2//EN">
<html>
<head>
<meta name="generator" content="HTML Tidy, see www.w3.org">
<title>questionario</title>
</head>
<body>
<form method="post" action="index.php3">
<p>Quale sistema operativo usi di più?</p>

<table border="0">
<tr>
<td>Windows 95/98/Me</td>
<td><input type="radio" name="voto" value="Windows 95/98/Me"></td>
</tr>

<tr>
<td>Windows NT/2000</td>
<td><input type="radio" name="voto" value="Windows NT/2000"></td>
</tr>

<tr>
<td>MacOS</td>
<td><input type="radio" name="voto" value="MacOS"></td>
</tr>

<tr>
<td>Linux</td>
<td><input type="radio" name="voto" value="Linux"></td>
</tr>

<tr>
<td>altro Unix</td>
<td><input type="radio" name="voto" value="altro Unix"></td>
</tr>
</table>

<p><input type="submit" value="vota"></p>
</form>
</body>
</html>Dobbiamo ora scrivere il codice PHP che effettua il conteggio delle scelte, che ovviamente deve essere salvato in qualche formato su disco. Una scelta conveniente è usare queste due funzioni, disponibili sin da PHP 3.0.5:
string serialize (mixed value);
mixed unserialize (string str);
Come risulta dal codice HTML visto prima, allo script viene passata una variabile $voto la quale indica univocamente mediante una etichetta (ad es. "Windows 95/98/Me") quale voto è stato espresso. Per memorizzare tutta la statistica, una struttura dati conveniente è un array associativo (spesso detto anche "hash") in cui l'indice è l'etichetta e il valore corrispondente a quell'indice indica il numero di voti espressi. Ho chiamato questo array $voti. Verso la fine dello script, $voti viene serializzato, ossia trasformato in una stringa che rappresenta valori e tipi della variabile, mediante la funzione serialize. La stringa viene poi scritta su disco in un file chiamato "voti.ser" (a cui potete dare il nome che vi pare comunque). All'inizio il programma recupera il valore precedente dell'hash voti leggendo il file voti.ser e deserializzandolo tramite la funzione unserialize.
Grazie a queste due funzioni e ad un semplice file di testo siamo quindi in grado di mantenere sul server lo stato dell'array voti tra una richiesta e l'altra. Notate anche che non occorre conoscere il formato di memorizzazione usato da serialize, anche se può essere interessante darci un'occhiata.
Ecco quindi index.php3 con l'aggiunta del codice che effettua la memorizzazione dei dati (tutto il codice aggiunto è evidenziato in neretto):

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 3.2//EN">
<html>
<head>
<meta name="generator" content="HTML Tidy, see www.w3.org">
<title>questionario</title>
</head>
<body>

<?

if (!empty($voto))
{
   # Cambia qui il nome del file di dati.
   # Se il file non esiste va creato vuoto in modo
   # che almeno l'utente web (di solito detto
   # apache o nobody) possa leggerlo e scriverlo.
   # Usa i comandi:
   #    # touch nome_file
   #    # chown apache.apache nome_file
   #    # chmod 600 nome_file
   define('DFN', 'voti.ser');

   # deserializza i dati da un file su disco
   $fp=fopen(DFN, 'r+b');
   # se il file può essere più grosso di 4096 bytes, aumentare ;)
   $voti=unserialize(fread($fp, 4096));

   # conteggia questo voto
   $voti[$voto]++;

   # serializza i dati sullo stesso file
   rewind($fp);
   fwrite($fp, serialize($voti));
   fclose($fp);

?>

<p>Grazie per aver votato. Torna alla <a href="/">home</a>.</p><?
}
else
{
?>
<form method="post" action="index.php3">
<p>Quale sistema operativo usi di più?</p>

<table border="0">
<tr>
<td>Windows 95/98/Me</td>
<td><input type="radio" name="voto" value="Windows 95/98/Me"></td>
</tr>

<tr>
<td>Windows NT/2000</td>
<td><input type="radio" name="voto" value="Windows NT/2000"></td>
</tr>

<tr>
<td>MacOS</td>
<td><input type="radio" name="voto" value="MacOS"></td>
</tr>

<tr>
<td>Linux</td>
<td><input type="radio" name="voto" value="Linux"></td>
</tr>

<tr>
<td>altro Unix</td>
<td><input type="radio" name="voto" value="altro Unix"></td>
</tr>
</table>

<p><input type="submit" value="vota"></p>
</form>

<?
}
?>
</body>
</html>

Lucchetti e semafori
Cosa avranno mai a che fare i lucchetti e addirittura i semafori con l'argomento di questo tutorial? L'algoritmo visto prima non funziona correttamente in ambiente multitasking, ma per mia fortuna non è da buttar via. Invece basta solo aggiungere un'istruzione per risolvere il problema, di cui ho già parlato una volta nel mio tutorial su PHP. Subito dopo la fopen aggiungete:

flock($fp, 2);

Se già conoscete il motivo di questa istruzione, potete passare al paragrafo successivo, altrimenti vale forse la pena di capirci qualcosa di più, anche se esula dall'argomento di questo tutorial. Vi propino una spiegazione semplice di un argomento secondo me non tanto facile da capire.
Considerate un file contenente dei dati che possono o devono essere modificati. Ammettete poi di essere in un ambiente multitasking (dove l'esecuzione di un processo viene sospesa per un certo tempo per continuare quella di un'altro precedentemente sospeso, poi viene sospeso il secondo e il primo viene ripreso ecc...) e che ci siano più processi che accedono a quel file in lettura e/o scrittura. In questa situazione si possono verificare dei problemi. Nel caso dell'esempio precedente siamo in ambiente multitasking, perché ci possono essere più copie dello stesso script index.php3 che accedono allo stesso file voti.ser create dal server web che utilizzate per ottimizzare in modo notevole le prestazioni (pensate a come lento sarebbe un server web che non può gestire un'altra richiesta se prima non è terminata la precedente). Apache ad esempio, il web server più usato su internet e ancora più diffuso in ambiente Unix, è un server multiprocesso e consiste in un processo genitore che coordina una serie di processi figli che poi sono quelli che servono le pagine.
Esemplifico un genere di problemi che si può verificare. Come detto prima, in un server multiprocesso come Apache, più persone possono accedere alle vostre pagine web praticamente nello stesso tempo. Quindi ci possono essere due o più processi che eseguono l'interprete PHP sul file index.php3 e che leggeranno e poi scriveranno nel file voti.ser. Detto in altri termini ci sono più persone che stanno esprimendo il loro voto contemporaneamente (o quasi). Per semplicità supponete siano solo due persone (a maggior ragione il problema si potrà verificare se sono di più). Quindi ci sono due persone che attivano l'esecuzione del programma index.php3. Ogni programma index.php3 apre in lettura il file voti.sar. Si può essere così sfortunati che può verificarsi ad es. una cosa del genere:

il programma 1 incrementa il contatore di Linux dal valore 43,768 a 43,769 e poi scrive il nuovo valore sul file.
il programma 2, quasi allo stesso tempo apre il file e legge il valoredel contatore 43,768. Supponendo che anche l'altro utente abbia votato per il pinguino, quello che può succedere è che il programma 2 incrementa il contatore di Linux e scriva il valore 43,769.

L'errore che si verifica è che avete perso un voto. Non è una grande tragedia, tuttavia significa che il nostro sistema di votazione online non è accurato e che più il sito è trafficato e meno accurato diventa, perché maggiore è la probabilità che si verifichino problemi come quello descritto sopra. Questo genere di problemi vengono detti in gergo "race condition".
Potete immaginare una soluzione per questo problema della race condition? Se ci pensate bene la soluzione dovrebbe essere ovvia:
ogni volta che volete leggere e scrivere in un file che potrebbe essere modificato da un altro processo, dovreste bloccare l'altro processo, impedendogli di modificare il file mentre il vostro processo lo vuole modificare ("file locking", dall'inglese to lock che significa bloccare, chiudere a chiave, mentre lock è la serratura).
In pratica occorre un meccanismo con cui il primo processo, quello che per primo ha messo le mani sul file, comunichi al secondo processo che sta tentando di aprire un file già aperto dal primo un messaggio che gli indichi che deve aspettare finché l'altro processo ha finito di usare il file. Chi prima arriva prima alloggia... e mette il lucchetto alla risorsa :)
Un modo per comunicare questo messaggio, usando un proprio meccanismo di locking, potrebbe consistere nel convenire di utilizzare un'altro file che in qualche modo, ad es. semplicemente attraverso la sua esistenza, comunica che il file voti.ser è bloccato. Questo file viene spesso chiamato "semaforo" (in inglese semaphore), perché analogamente ai semafori stradali che segnalano quando la strada è libera o occupata, questo file segnala quando una risorsa di sistema (nel nostro esempio l'altro file voti.ser) è disponibile. Il codice seguente implementa in PHP questo tipo di file-locking usando un proprio file di lock:

while (file_exists('voti.ser.lock'))
{
usleep(1000);
clearstatcache();
}
$lock_fp=fopen('voti.ser.lock','w');
...
# codice che legge e/o scrive voti.ser, come sopra
...
fclose($lock_fp);
unlink('voti.ser.lock');
Questo codice come vedremo purtroppo è da buttare, comunque è molto istruttivo descriverne il funzionamento. Con la funzione file_exists controlliamo se il file di lock esiste. Se esiste vuol dire che un altro processo sta usando il file voti.ser. Se siamo in questo caso col while precedente il nostro processo aspetterà finché il file di lock, voti.ser.lock non esiste più. Aspetterà anche all'infinito, ma questo è un altro problema che possiamo supporre che in condizioni normali non si verifichi. Tra uno sguardo e l'altro al semaforo attendiamo un tempo definito dal parametro della funzione usleep, per non appesantire il sistema con una raffica di chiamate a file_exists. Usiamo usleep perché la funzione sleep() accetta un numero intero di secondi come unità di ritardo, che per un lock è un tempo molto lungo di attesa. Considerando la notevole velocità dei calcolatori, il tempo necessario ad uno sblocco dovrebbe essere mediamente solo di alcuni microsecondi. L'argomento della funzione usleep è il numero di microsecondi di attesa (la u è una stilizzazione della lettera greca mu spesso usata per indicare un milionesimo).
Quando il file di lock non esiste più, il programma sa che può creare il suo file di lock e cominciare a modificare il file voti.ser. Perciò crea un file di lock con la funzione fopen. Con questo comando, il programma dice a tutti gli altri programmi che sta per modificare il file voti.ser e lo blocca, come quando si mette il lucchetto a qualcosa. Quando il programma ha finito di riscrivere il file voti.ser, chiude il file di lock (voti.ser.lock) e poi usa la funzione unlink per cancellare il lock file. Dopo che il lock file è stato cancellato, un altro programma che stava aspettando su quel semaforo può reiniziare il processo che abbiamo descritto.
Il file di lock che abbiamo usato non è un file speciale; è solo un nome di file comune usato da ogni processo che vuole modificare il file voti.ser. Per convenzione ho scelto di utilizzare il nome del file da bloccare più l'ulteriore estensione .lock come nome del file di lock, ma è solo una buona convenzione. Il file di lock viene creato da una comune chiamata a fopen e cancellato tramite il comando unlink. Quando un file di lock esiste, ogni processo sa che deve aspettare prima di modificare il file bloccato (voti.ser nel nostro caso).
Note:

La funzione usleep non è supportata dai sistemi Windows, perciò siete costretti ad usare sleep(1). Naturalmente sovradimensionare il tempo di ritardo non produce errori, solo riduce le prestazioni, similmente ad avere un tempo di ritardo molto più basso del tempo medio di sblocco o del tutto nullo. Inoltre la funzione unlink può non funzionare sui sistemi Windows. Avete capito quindi quale sistema conviene usare con PHP ;)
La ragione della chiamata della funzione clearstatcache è dovuta al fatto che l'interprete PHP, allo scopo di aumentare le prestazioni si tiene in una cache i risultati dell'ultima chiamata a molte funzioni che hanno a che fare col filesystem, tra cui file_exists. Se la prossima chiamata a file_exists viene fatta con lo stesso nome di file come argomento, l'interprete restituisce il valore messo nella cache, senza rifare alcun controllo dello stato attuale del file. Poiché nel nostro caso lo stato del file voti.ser.lock viene controllato molte volte e può cambiare repentinamente (il file stesso può scompare perché un altro processo toglie il lock al file), occorre chiamare la funzione clearstatcache per svuotare la cache prima di fare un'altra chiamata a file_exists, forzando così file_exists ad effettuare un vero e proprio controllo sullo stato del file tramite le funzioni del sistema operativo. Devo anche precisare che ogni singola richiesta usa una cache separata per le funzioni che operano sul filesystem che viene rilasciata al termine della richiesta stessa.

Se siete acuti avrete già notato cosa c'è che non va nel programma precedente. Il problema è rappresentato dal multitasking. Chi vi assicura che subito dopo essere usciti dal ciclo while e prima che l'azione della fopen sia portata a completamento, il sistema operativo non decida di interrompere l'esecuzione e passare ad un altro processo index.php3? In questo caso il primo processo, quando se ne riprende l'esecuzione, considera il file voti.ser sbloccato, e questo potrebbe non esserlo, con la conseguenza che si verifica di nuovo una "race condition". Anche se le probabilità sono minori rispetto al caso in cui non c'è alcun controllo sull'accesso contemponeraneo alla risorsa, il baco rimane.
Per risolvere questo problema occorrerebbe assicurare che le due operazioni di verifica dell'esistenza del lock e creazione di un nuovo lock siano "atomiche", vale a dire non interrompibili. Non c'è in PHP alcuna funzione per assicurare questo, mentre in assembly sì. Tuttavia in PHP non avete bisogno di programmarvi un meccanismo di locking. Poiché il file locking è spesso necessario, PHP vi mette a disposizione una funzione sicura e semplice da usare per effettuare questo task che si appoggia a sua volta ad una system call del vostro sistema operativo.
Quindi invece di usare un vostro meccanismo di locking, dovreste usare uno dei meccanismi di locking di sistema, che garantiscono il funzionamento corretto della procedura di locking in tutti i casi e sono accessibili dal PHP tramite la funzione flock, sia su piattaforma Unix che Windows.
La funzione flock (che sta per "file lock") ha la seguente sintassi:

bool flock (int fp, int 
  operation [, int wouldblock])

Per il tipo di locking che ci serve a noi (lock esclusivo, che può essere posseduto solo da un processo per volta), settate operation uguale a 2 oppure a LOCK_EX (se avete PHP >=4.0.1). fp è l'handle del file da lockkare ritornato da fopen. Se passate il valore 3 (o LOCK_UN per PHP>=4.0.1) il lock viene rilasciato. Comunque un lock viene rilasciato all'atto della chiusura del file su cui vige tramite fclose, quindi possiamo risparmiarci di chiamare prima la flock.
Definendo un lock esclusivo (exclusive lock) sul file, quando un altro processo tenta di accedere al file bloccato, chiamando a sua volta la flock, questa chiamata della flock lo pone in attesa finché il file non viene sbloccato dall'altro processo e appena viene sbloccato stabilisce un nuovo lock sul file. Il codice eseguito dalla flock è simile a quello del nostro meccanismo di locking, ma garantisce l'atomicità della sequenza di operazioni di verifica e acquisizione del lock. Oltretutto la flock è anche più semplice da usare: apri il file, poi passi il filehandle a flock. Se un altro processo cerca di usare il file si bloccherà al comando flock() finché il primo processo ha finito col file. Non c'è altro da fare.
$fp=fopen(DFN, 'r+b');
flock($fp, 2);
...
# codice che legge e/o scrive voti.ser, come sopra
...
fclose($fp);
Naturalmente questo meccanismo di locking è consultivo (advisory lock), perché la flock non ha il potere di bloccare l'accesso fisico al file: se un processo non chiama la flock e quindi non attende sulla flock lo sbloccaggio, si può verificare lo stesso la condizione di gara. Assicuratevi perciò che tutti i processi che accedano al file comune usino lock. Nel caso precedente avevamo tutti processi identici copie di un unico codice, quello di index.php3 e quindi ogni copia per il fatto di essere identica alla prima usa flock.
Il primo grafico
Torniamo all'argomento principale di questo tutorial. Nella prima versione del nostro semplice questionario online, anziché presentare le statistiche viene stampato il messaggio "Grazie per aver votato. Torna alla home". Si tratta adesso solo di sostituire quel messaggio con la stampa del grafico delle statistiche. I dati, compreso l'ultimo voto conteggiato, sono già disponibili nell'array $voti. Naturalmente, essendo in un contesto multitasking, potrebbe accadere che subito dopo aver registrato un voto e prima che venga emesso il grafico, il processo venga sospeso per registrare un altro voto e quando si ritorna al primo utente, questo si ritrova stampata una statistica falsata per mancanza di un voto. Pensavate di esservene liberati eppure troviamo di nuovo qui il problema del locking. La cosa non è qui così grave, poiché i voti vengono comunque registrati correttamente grazie al file locking, ma è così semplice porre rimedio al problema che non ho resistito. Basta ritardare la chiusura del file puntato da $fp a dopo la stampa del grafico, in modo che il lock sul file rimanga anche durante la stampa del grafico stesso. In pratica lettura, aggiornamento del file voti.ser e stampa della statistica sono operazioni che ogni processo index.php3 deve portare a termine, prima che possa iniziarle un altro processo.
Veniamo ora finalmente alla generazione del grafico con HTML_Graphs. La prima cosa è includere la libreria. Ho messo index.php3 nella directory web /quest e lì dentro ho creato dei link simbolici con lo stesso nome ad HTML_Graphs.php3 (che sta in /HTML_Graphs) e alle immagini contenute nella sottodirectory images di /HTML_Graphs che useremo tra poco usando il comando Unix "ls -s nomefile nomelink". In questo modo scrivo semplicemente:

require('HTML_Graphs.php3');

Per creare un grafico a barre orizzontali è sufficiente chiamare la funzione html_graph che genera il codice HTML necessario. I parametri che è obbligatorio passare sono 4:

un array contenente le etichette delle barre. Nel nostro caso passiamo semplicemente l'array formato dalle chiavi di $voti, cosa che rende il nostro codice più generico e più semplice. Per ottenere la lista delle chiavi di un array associativo sotto forma di un array scalare basta chiamare la funzione array_keys sull'array associativo.
l'array dei valori di ogni barra ordinati in modo corrispondente alle etichette delle barre indicate nell'array precedente.
l'array dei corrispondenti codici di colore delle barre. Un codice di colore va preceduto da # come in HTML, altrimenti si intende il percorso di un file di immagine che verrà usato come tile per riempire la barra. Con i grafici verticali si possono usare solo i file di immagine.
un array associativo che definisce lo stile dell'intero grafico, documentato con precisione in HTML_Graphs.php3. Tutte le chiavi hanno associati dei valori di default. L'unico valore che nel nostro caso è necessario cambiare è il fattore di scala che per default vale 1.

Un problema è rappresentato dal fatto che il nostro codice ordina gli elementi dell'array $voti a seconda di come gli vengono i primi voti. Per far sì che gli elementi dell'array $voti siano nello stesso ordine in cui sono presentati nella form di votazione, basta creare un array $voti in cui gli elementi sono in quest'ordine ed i voti sono tutti zero e scriverlo come valore iniziale nel file voti.ser. La cosa è banale, comunque se avete intenzione di usare lo script sul vostro sito per proporre periodicamente dei sondaggi, conviene farsi uno scriptino facilmente riutilizzabile per inizializzare il file voti.ser. Ho chiamato questo script reset.php3. Dovete semplicemente inizializzare l'array $voti (che stavolta è un semplice array) e lanciare lo script da web oppure da riga di comando se avete installato la versione CGI di PHP. Dopodiché eliminate lo script dalla directory web in modo che nessun utente web abbia la possibilità di invocarlo e di resettarvi le statistiche.

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 3.2//EN">
<html>
<head>
<meta name="generator" content="HTML Tidy, see www.w3.org">
<title>reset del questionario</title>
</head>
<body>

<?
   # se avete installato PHP da linea di comando potete
   # lanciare questo script da linea di comando con:
   #    # php reset.php3
   # altrimenti lanciatelo da web

   # Cambia qui il nome del file di dati.
   # Se il file non esiste va creato vuoto in modo
   # che almeno l'utente web (di solito detto
   # apache o nobody) possa leggerlo e scriverlo.
   # Usa i comandi:
   #    # touch nome_file
   #    # chown apache.apache nome_file
   #    # chmod 600 nome_file
   define('DFN', 'voti.ser');

   # definisci qui i voti iniziali
   # nell'ordine desiderato per il grafico
   # attenzione: le chiavi devono corrispondere
   # ai valori degli attributi value nei
   # tag <input type="radio"> di index.php3
   $voti = array(
     'Windows 95/98/Me' => 0,
         'Windows NT/2000'      => 0,
         'MacOS'                        => 0,
         'Linux'                        => 0,
         'altro Unix'           => 0
   );

   # serializza voti tutti nulli
   $fp=fopen(DFN, 'wb');
   fwrite($fp, serialize($voti));
   fclose($fp);
?>

<p>Fine dello script. Ricordarsi di rimuoverlo o spostarlo in modo
che non possa essere più invocato via web.</p>
</body>
</html>

Ecco quindi la prossima versione di index.php3 che finalmente genera il grafico delle statistiche dopo la votazione:

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 3.2//EN">
<html>
<head>
<meta name="generator" content="HTML Tidy, see www.w3.org">
<title>questionario</title>
</head>
<body>

<?

if (!empty($voto))
{
   # Cambia qui il nome del file di dati.
   # Questo file va creato usando lo script reset.php3
   define('DFN', 'voti.ser');

   # deserializza i dati da un file su disco
   $fp=fopen(DFN, 'r+b');
   flock($fp, 2);
   # se il file può essere più grosso di 4096 bytes, aumentare ;)
   $voti=unserialize(fread($fp, 4096));

   # conteggia questo voto
   $voti[$voto]++;

   # stampa il grafico con HTML_Graphs
   require('HTML_Graphs.php3');

   $names = array_keys($voti);
   $values = array_values($voti);
   $largest = max($values);
   # alcuni colori per le barre: blu, verde, fucsia, rosso, ciano
   $bars = array('#0000ff', '#00ff00', '#ff00ff', '#ff0000', '#00ffff');
   # scale = fattore che moltiplicato ai valori fornisce la
   # dimensione della barra. Il valore maggiore $largest avrà
   # una barra lunga 150 pixel settando scale a 150/$largest
   $graph_vals = array('scale'=>150/$largest);

   html_graph($names, $values, $bars, $graph_vals);
   # serializza i dati sullo stesso file
   rewind($fp);
   fwrite($fp, serialize($voti));
   fclose($fp);
}
else
{
?>

<form method="post" action="index.php3">
<p>Quale sistema operativo usi di più?</p>

<table border="0">
<tr>
<td>Windows 95/98/Me</td>
<td><input type="radio" name="voto" value="Windows 95/98/Me"></td>
</tr>

<tr>
<td>Windows NT/2000</td>
<td><input type="radio" name="voto" value="Windows NT/2000"></td>
</tr>

<tr>
<td>MacOS</td>
<td><input type="radio" name="voto" value="MacOS"></td>
</tr>

<tr>
<td>Linux</td>
<td><input type="radio" name="voto" value="Linux"></td>
</tr>

<tr>
<td>altro Unix</td>
<td><input type="radio" name="voto" value="altro Unix"></td>
</tr>
</table>

<p><input type="submit" value="vota"></p>
</form>

<?
}
?>

</body>
</html>

Ecco poi un esempio dell'aspetto che ha il grafico sul mio browser Mozilla:
primo esempio di grafico

Le barre sono state generata da HTML_Graphs come delle celle di tabella contenenti un "nonbreaking space" ( ), un trucco noto un po' a tutti i webmaster per evitare che alcuni browser non disegnino proprio delle celle di tabella che si vogliono vuote. Possiamo migliorare il grafico, aggiustando vari parametri. Prima di tutto mettiamo più spazio tra le barre ed inseriamo un titolo. Per fare questo basta aggiungere qualche parametro nell'hash $graph_vals:

   $graph_vals = array(
     'scale'        => 150/$largest,
     'hlabel'       => '# di voti',
     #'border'       => 1,
     'cellpadding' => 4
   );

border specifica la dimensione del bordo della tabella più esterna ed è utile in fase di sviluppo per rendervi conto di com'è la struttura tabellare con cui è costruito il grafico. cellpadding imposta lo spazio tra le celle ed il contenuto per questa tabella principale. Il risultato della modifica è mostrato in figura:
Il grafico migliorato

A questo punto provvedere un link per visualizzare il grafico senza registrare alcun voto è piuttosto semplice: passiamo un parametro flag (stat=on) per indicare che vogliamo le statistiche e non vogliamo alcuna votazione. Un paio di if e il gioco è fatto.
Per evitare che un valore zero venga comunque rappresentato con uno spazio, potete usare delle immagini che verrano "stirate" per costituire le barre. Per far questo basta modificare l'array $bars ad es. come segue:

   $bars = array(
     'images/hbar_blue.gif',
     'images/hbar_green.gif',
     'images/hbar_orange.gif',
     'images/hbar_red.gif',
     'images/hbar_aqua.gif'
   );

Quando ci sono le immagini potete trasformare un grafico a barre orizzontali in uno a barre verticali in uno snap. Il grafico orizzontale è del tipo 0 (predefinito), quello verticale del tipo 1, quindi aggiungete questo elemento all'array $graph_vals:

'type' => 1

Come fare un sondaggio



Salve a tutti.........ci sono molte applicazioni web che un utente può usare per 
arricchire il proprio sito e renderlo 

più interessante e dinamico. Una di queste sono i sondaggi. Questo sondaggio (Ho 
messo delle squadre solo cosi per indicazione)che vi sto per illustrare e creato 
in php naturalmente appoggiandosi ad 

un database Mysql con qualche effetto di javascript. Non ho curato la grafica 
l'ho solo fatto funzionare poi ognuno sceglie la grafica migliore. 

E' molto facile da comprendere come state per vedere. Scusate gli "Orrori" di 
ortografia e altro...... 

Questa applicazione e ha i seguenti file.... 

1)db_connect.php 

2)install.php 

3)scegli.htm 

4)vai.php 

5)guarda.php 

6)vota.gif 

Guardiamoli uno per uno le loro funzionalità 

1)db_connect.php 

Questo è il file che verra incluso nei file vai.php, guarda.php. E il file di 
connessione a mysql e di selezione al database 

PHP:


  <?php 

  mysql_connect("localhost", "root") or die("Impossibile 
  connettersi al database"); 

  mysql_select_db("sondaggio") or die("Impossibile 
  selezionare il database"); 

  ?>

Come si puo notare dopo essermi 
connesso al database seleziono la tabella sondaggio che ancora non ho creato ma 
che faro presto 

2)install.php 

Questo file è quello che uso per installare la mia tabella. Per sicurezza dopo 
aver creato la tabella cancello il file.Ora posto il codice e poi lo commentiamo 
zona per zona. 

PHP:


  <?php 

  $connessione=mysql_connect("localhost", "root") or die("Impossibile 
  connettersi al database"); 

  if ($connessione) {
  

  echo "Connessione a mysql riuscita<br>";
  

  }else{ 

  echo" Connessione fallita<br>";
  

  } 

  

  $database=  mysql_create_db(sondaggio,$connessione);

  

  if ($database) { 

  echo "Creazione  database riuscita<br>";
  

  }else{ 

  echo" Creazione database fallita probabilmente 
  c'e già<br>"; 

  } 

  

  $db_name="sondaggio";
  

  $selezione= mysql_select_db($db_name);
  

  if ($selezione) {
  

  echo "Selezione  database riuscita<br>";
  

  }else{ 

  echo" Selezione fallita<br>";
  

  } 

  

  $creatabella= "CREATE 
  TABLE nomi ( 

  id INT (5) UNSIGNED not null AUTO_INCREMENT, 

  italia  DECIMAL, 

  portogallo  DECIMAL, 

  spagna  DECIMAL, 

  francia  DECIMAL, 

  inghilterra  DECIMAL, 

  PRIMARY KEY (id))"; 

  

   $crea=mysql_query($creatabella,$connessi

  one) or die("Impossibile eseguire la query <b>$ciao</b><a href=\"inserisci.php\"><br>Inserisci un messaggio</a><br><br><b>Errore</b>:".mysql_error());
  

  

  

  if ($crea) { 

  echo "Creazione Tabella riuscita<br>";
  

  }else{ 

  echo" Creazione  Tabella fallita<br>";
  

  

  

  } 

  

  $creatabella= "INSERT 
  INTO nomi (italia, portogallo, spagna, francia, inghilterra) 

  VALUES( 

  '0', 

  '0', 

  '0', 

  '0', 

  '0' 

  ) 

  

  "; 

  

  $crea=mysql_query($creatabella) or die("Impossibile eseguire la query <b>$ciao</b><br><b>Errore</b>:".mysql_error());
  

  

  if ($crea) { 

  echo "Inserimento riuscito<br>";
  

  }else{ 

  echo"Inserimento Fallito<br>";
  

  } 

  

  mysql_close(); 

  ?>

Logistoris

domenica 30 ottobre 2011

link a rss

giovedì 27 ottobre 2011

xmplparser esempio php

trucchi ed esempi php

Archivio blog

Pagine

Visualizzazioni totali

Argomenti