PHP & MySQL
I suggerimenti sono stati presi da riviste di informatica, da newsletters o da siti web
perciò ogni diritto rimane al legittimo proprietario.


Tips Utility
Links Esempi PHP
Campi in MySql PHP MYSQL Functions

 

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

InnoDB vs MyISAM

Oggi vedremo le principali differenze tra InnoDB e MyISAM e cercheremo di capire quando usare uno o l’altro. Iniziamo ad elencare qui di seguito le caratteristiche di ognuno e subito dopo vedremo i vantaggi e gli svantaggi.

VANTAGGI di InnoDB

  1. Essendo più rigido riguardo il data integrity, dovrebbe essere usato quando si hanno applicazioni dove il data integrity è di “vitale importanza”, come ad esempio banche, trasazioni online, etc.
  2. Utilizzando il row-level lock è molto più veloce in lettura/scrittura se nella tabella avvengono molteplici inserimenti/update rispetto al MyISAM che effettua il lock dell’intera tabella per ogni singola operazione d’inserimento/update.

SVANTAGGI di InnoDB

  1. Viene impiegato molto tempo per creare lo schema del DB visto che devono essere rispettate le relazioni tra le singole tabelle
  2. Utilizza più risorse (RAM) rispetto a MyISAM
  3. Non ha il full-text indexing

VANTAGGI di MyISAM

  1. Veloce e facile nella crazione del DB
  2. Non usa molte risorse
  3. Ha il full-text indexing
  4. Ottimo se le tabelle vengono utilizzare molto in lettura

SVANTAGGI di MyISAM

  1. Non ha il data integrity, questo significa che è compito dello sviluppatore occuparsene
  2. Non supporta le transaction, questo implica che non è ideale per applicazioni bancarie o simili
  3. E’ più lento se vengono effettuati molteplici inserimenti/update

THE WINNER IS…
InnoDB è ideale per applciazioni dove il data integrity è importante e dove ci sono molteplici inserimenti e update, metre MyISAM è veloce e ideale per applicazioni dove vengono effettuate molteplici select e sono poco dipendente dal data integrity.

Differenza tra le tabelle di tipo MyISAM e InnoDB.
Il popolare Database Server MySQL dispone di vari tipi di tabelle. Le più usate sono senza dubbio le MyISAM e le InnoDB. In questo breve tutorial cercheremo di capirne le differenze.
MyISAM
Sono le tabelle "storiche" di MySQL. Hanno fatto il loro successo grazie alle ottime performace e al ridotto carico sul server che necessitano. Purtroppò però mancano di alcune caratteristiche molto importanti nelle basi di dati; primo fra tutte il mancato supporto alle foreign key (chiavi esterne), grazie alle quali è possibile creare relazioni tra tabelle e applicare il concetto di integrità referenziale. Mancano inoltre del supporto alle transazioni. Mancando il supporto alle transazioni e alle foreign keys solitamente non sono adatte per realizzare sistemi di commercio elettronico o altre applicazioni enterprise.
Le tabelle di tipo MyISAM si compongono di 3 file con estensioni .frm, .MYD e .MIY. Il primo file contiene la struttura della tabella, il secondo i dati e il terzo gli indici.
Per trasferire una tabella da una macchina ad un'altra è sufficiente spostare questi 3 file. Il tipo di tabella MyISAM è solitamente quello predefinito nel DBMS.
InnoDB
Sono tabelle molto più complete rispetto alle MyISAM ma si sono fatte la nomina di essere più lente a causa delle funzionalità aggiuntive di cui dispongono. Vorrei fermarmi un attimo proprio su questa questione delle performance: ritengo che al giorno d'oggi la differenza reale di prestazioni tra MyISAM e InnoDB sia divenuta veramente minima.
Tra le caratteristiche a loro vantaggio, invece, vi sono le foreign key e la transazionalità, con le quali è possibile creare una base di dati relazionale e transazionale.
Per trasferire questo tipo di tabelle da un server ad un altro non è sufficiente spostarne i file e questo rende più complicate le procedure di backup. Questo tipo di tabelle, inoltre, non sono sempre disponibili negli hosting economici.

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
<!--[if !supportEmptyParas]--> <!--[endif]-->
<?
/********************* 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 = '&nbsp;'; // we're on page one, don't print previous link
$first = '&nbsp;'; // 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 = '&nbsp;'; // we're on the last page, don't print next link
$last = '&nbsp;'; // 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>&nbsp;
</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&agrave;</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&agrave; 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

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.

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 &copy; $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>
<!-- Inizio HEADER -->
<?php include("header.php"); ?>
<!-- Fine Header -->
<!-- Inizio codice pagina -->
<div id="corpo">
Qui il codice della pagina
</div>
<!-- Fine codice pagina -->
<!-- Inizio codice footer -->
<?php include("footer.php"); ?>
<!-- Fine codice footer -->
</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&amp;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("&", "&amp;", $content);
echo "<item>
<title>$title</title>
<link>http://www.tagtagweb.com/index.php?blog=post&amp;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>&nbsp;</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>&nbsp;</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 &nbsp; 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&nbsp;&nbsp;
<br>&nbsp;&nbsp; <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:

Quale sistema operativo usi di più?

Windows 95/98/Me
Windows NT/2000
MacOS
Linux
altro Unix

 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&ugrave;?</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&ugrave;?</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:

  1. il programma 1 incrementa il contatore di Linux dal valore 43,768 a 43,769 e poi scrive il nuovo valore sul file.
  2. 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:

  1. 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 ;)
  2. 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:

  1. 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.
     
  2. l'array dei valori di ogni barra ordinati in modo corrispondente alle etichette delle barre indicate nell'array precedente.
  3. 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.
  4. 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&ugrave; 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&ugrave;?</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" (&nbsp;), 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";
$selezionemysql_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();
?>

Come si puo' notare da codice queste sono le prime tre operazioni
Mi collego al database
Creo la tabella
Seleziono la tabella
Dopo avere fatto questo cerchiamo di installare la tabella e strutturare il nostro database con
quote:


PHP:



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

Come si nota creo una tabella nomi con i nomi delle squadre che nel campo hanno come descrizione DECIMAL (cosi dico a mysql che li andranno numeri decimali).
Poi faccio la query e la controllo
Il file non è pero finito qui perche subito dopo vi trovate questo codice
quote:


PHP:


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

Questo codice grazie alla voce INSERT INTO mi fa inserire dati nei campi che io impostero a zero.Poi faccio la query e controllo. Avrei potuto agire in due modi:
Uno è quello di settare i campi a zero cosiche io ogni volta che si vota incremento di uno
L'altro era di lasciare stare pero poi quando si votava dovevo controllare che il campo non fosse nullo e quindi non devo incrementare ma mettere uno.
Mi spiego meglio
Nel primo caso quando si vota faccio in modo che php legga nel database e mi incrementi di uno il numero. Nel secondo(se non setto tutto i campi = a 0) php non riesce a
incrementarmi i dati di uno perche i campi hanno valore null, quindi io devo fare in modo che se il campo è vuoto si inserisca uno altrimenti si incrementi.
Siccome la via piu breve era la prima ho scelto quella.
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_mys
ql
))
{
$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_mys
ql
))
{
$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_mys
ql
))
{
$spagna=$riga1["spagna"];
$italia=$riga1["italia"];
$portogallo=$riga1["portogallo"];
$francia=$riga1["francia"];
$inghilterra=$riga1["inghilterra"];

}


 
$totale=$spagna+$italia+$portogallo+$fra
ncia
+$inghilterra;
echo 
"In totale ci sono $totale voti";

$percspagna$spagna*100/$totale;
$s=round($percspagna2);


$percitalia$italia*100/$totale;
$i=round($percitalia2);


$percfrancia$francia*100/$totale;
$f=round($percfrancia2);


$percportogallo$portogallo*100/$totale;
$p=round($percportogallo2);


$percin$inghilterra*100/$totale;
$n=round($percin2);

//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 può essere implementata in tanti modi per far si che non si possa votare più di 1 volta in un giorno.
Si può 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.....
Se qualcuno ha altre implementazioni per i sondaggi le posti pure io l'ho fatto in modo veloce....
COMMENTI
la tabella non mi sembra fatta bene...

PHP:


CREATE TABLE nomi (
id INT (5UNSIGNED not null AUTO_INCREMENT
italia  DECIMAL,
portogallo  DECIMAL,
spagna  DECIMAL,
francia  DECIMAL,
inghilterra  DECIMAL,
PRIMARY KEY (id
))


In questo modo se vogliamo cambiare le risposte al sondaggio bisogna cambiare nomi ai campi...secondo me sarebbe meglio fare tre celle per campo...tipo
domanda | Chi vincerà gli europei
risposta1 | Francia | numero voti
risposta2 | Danimarca* | numero voti
risposta3 | Portogallo | numero voti
risposta4 | Spagna | numero voti
risposta4 | Inghilterra | numero voti
*Non ho messo Italia per ovvi motivi scaramantici

Rotazione BANNER
Grazie a questo script sarà possibile mostrare dei banner in ordine casuale e, ovviamente, con relativo link (con target personalizzabile).
Possiamo inserire lo script sia nel punto esatto della pagina in cui vogliamo che appaiano i banner e sia richiamandolo dall'esterno
Per inserirlo nella pagina:
<script language="JavaScript">
var openInNewWin = true;
var banners = new Array();
banners[0] = new Banner("http://www.nomesito.it", "Visita il primo sito", "1.gif");
banners[1] = new Banner("http://www.nomesito2.it", "Visita il sito 2", "2.gif");
banners[2] = new Banner("http://www.nomesito3.it", "Visita il terzo sito", "3.gif");
banners[3] = new Banner("http://www.nomesito4.it", "Visita il quarto sito", "4.gif");
banners[4] = new Banner("http://www.nomesito5.it", "Visita l'ultimo sito", "5.gif");
function Banner(url, description, image) {
this.url = url;
this.description = description;
this.image = image;
return this;
}
var bNum = Math.round(Math.random() * (banners.length - 1));
document.write("<a href=\"" + banners[bNum].url + "\"");
if (openInNewWin) {
document.write(" target=\"_blank\"");
}
document.write(">");
document.write("<img src=\"" + banners[bNum].image + "\" border=\"0\" alt=\"" + banners[bNum].description + "\">");
document.write("</a>");
</script>
Personalizziamo, ora, lo script descritto sopra.
var openInNewWin = true;
per utilizzare un target specifico (vedi dopo) settiamo TRUE altrimenti FALSE (e il link verrà aperto nella pagina attuale).
Poi vanno preparate le stringhe (array) contenenti i dati di ogni singolo banner: potete inserirne quante ne volete purchè rispettiate la numerazione progressiva partendo da zero.
Adesso bisogna impostare il target che vogliamo (in questo caso _blank)
document.write(" target=\"_blank\"");
Un consiglio: poichè il codice è abbastanza lungo, potrebbe farvi comodo, per una maggiore "pulizia" della pagina e leggibilità, richiamare questa funzione dall'esterno.
Copiate il codice sopra (senza però i tag <script language="JavaScript"> e </script>) in un file di testo fatto con Notepad e salvatelo con estensione .js (es. chgbanner.js).
A questo punto basterà inserire il richiamo a questo file appena creato nelle pagine da noi desiderate in questo modo:
<script language="Javascript" src="chgbanner.js"></script>
=======================================================
Un circuito di rotazione banner in Php
La funzione rand() di Php, combinata all'utilizzo degli array, permette in maniera semplice e veloce di creare un circuito di rotazione banner che mostra sulla pagina un banner a caso preso dall'elenco dell'array.
Si crei il file banner.php che conterrà il la funzione per la rotazione del banner; di seguito il codice corredato di opportuni commenti:
<?PHP
// CREO LA FUNZIONE DA RICHIAMARE SULLE PAGINE PHP
function MioBanner()
{
// CREO L'ARRAY CHE CONTIENE I BANNER
$banner[] = "lukeonweb.gif";
$banner[] = "mrwebmaster.gif";
// CREO L'ARRAY CHE CONTIENE LE URL ASSOCIATE AI BANNER
$url[] = "http://www.lukeonweb.net";
$url[] = "http://www.mrwebmaster.it";
// EFFETTUO LA SCELTA CASUALE DEL BANNER
$totale = count($banner) - 1;
$casuale = rand(0, $totale);
// STAMPO IL BANNER A VIDEO COL RELATIVO LINK ASSOCIATO
print "<a href='" . $url[$casuale] . "' target='_blank'><img src='" . $banner[$casuale] . "' border='0'></a>";
}
?>
Richiamiamo poi nel seguente modo la funzione MioBanner() in tutte le pagine che ci interessano, includendo il file banner.php nelle pagine:
<?PHP
require("banner.php");
?>
<html>
<body>
<p align="center">
<?PHP
MioBanner()
?>
</p>
</body>
</html>

Paginazione dei dati presenti in un file di testo senza uso di database
In questo tutorial si parla di una cosa che potrebbe interessare molto persone, soprattutto quelle che non hanno la possibilità di inserire i loro dati in bel database MySQL!
Infatti, ora vedremo come riuscire a paginare (ossia visualizzare un tot di dati per pagina) i dati presenti in un file di testo.
Come prima cosa, cominciamo a creare le variabili di configurazione, ecco il codice:
$file = file("./file.txt");
if($perpage == FALSE) $perpage = 30;
if($pos == FALSE) $pos = 0;
$count = count($file);
Vediamo un pò che cosa vogliono dire quelle stringhe di codice:
La variabile $file serve appunto per selezionare il nostro file, $perpage per decidere quanti record visalizzare per pagina, $pos sta a indicare il numero della pagina e infine $count serve a vedere il numero totale dei record.
Passiamo ora alla visualizzazione dei record.
Ecco il codice:
for($i = $pos; $i < ($perpage+$pos); $i++)
{
if($i > $count-1) break;
$result = explode("|", trim($file[$count-$i-1]));

echo "<li>$result[0] $result[1]\n";
}
Ora spieghiamo un pochino che cosa vuol dire quel insieme di simboli :)
Per prima cosa vorrei far notare il metodo usato per la visualizzazione dei records: si usa il ciclo for().
Questa parte (come la successiva) è totalmente personalizzabile inquanto si può decidere in che modo mostrare i nostri record, o al contrario, se non dovessero essercene.
In questa parte l'unica variabile da commentare è $result; anche questa variabile può essere leggermente modificata, o meglio... è possibile modificare il carattere separatore (che in questo caso è "|")
Come ultima cosa, vediamo come creare una specie di navigatore: con il codice sottostante è possibile scegliere che pagina visualizzare.
Vediamo come fare:
echo "<div align=\"center\">[ ";
for($p = 0; $p < $count; $p++)
{
if(!($p % $perpage))
{
$pg = ($p/$perpage)+1;
if ($p == $pos)
{
echo "<strong>$pg</strong> ";
}
else
{
echo "<a href=\"?pos=$p\">$pg</a> ";
}
}
}
echo " ]</div>";
In questa parte c'è davvero poco da dire.
L'unica cosa che è possibile modificare è il modo di visualizzazione delle pagine.
Ma questo sta alla vostra fantasia... :))
Ecco a voi il codice completo:
<?php
$file = file("./file.txt");
if($perpage == FALSE) $perpage = 30;
if($pos == FALSE) $pos = 0;
$count = count($file);
for($i = $pos; $i < ($perpage+$pos); $i++)
{
if($i > $count-1) break;
$result = explode("|", trim($file[$count-$i-1]));

echo "<li>$result[0] $result[1]\n";
}
echo "<div align=\"center\">[ ";
for($p = 0; $p < $count; $p++)
{
if(!($p % $perpage))
{
$pg = ($p/$perpage)+1;
if ($p == $pos)
{
echo "<strong>$pg</strong> ";
}
else
{
echo "<a href=\"?pos=$p\">$pg</a> ";
}
}
}
echo " ]</div>";
?>
Estrapolare dei dati da un file esterno
$file = "ciccio.txt";
$fd = fopen($file, "r");
$DATA = fgets($fd, 4096);
$data_exploded = explode("-", $DATA);
$num = count($data_exploded);
for ($i = ($num - 1); $i >= 0; $i--)
{
echo $data_exploded["$i"];
echo '
';
}
?>
Questa funzione mostra a video il contenuto di un file ciccio.txt strutturato in questo modo: DATO1-DATO2-DATO3-DATOn
La funzione è strutturata per un numero di dati infiniti, ma solo cambiando il valore 4096, che indica la quantità di memoria utilizzabile per quel processo. Vi consiglio di tenere questo valore sufficientemente basso per evitare di piantare il Web Server!

Realizziamo una feedback form
Dare la possibilità ai visitatori del proprio sito di interagire con noi e di inviarci commenti e opinioni migliora la fruibilità del nostro sito. Questo brevissimo tutorial di Stevie Peele ci mostra, per mezzo di un esempio pratico completamente funzionante, come implementare una feedback form in PHP che si basa sulla funzione mail().
Per prima cosa, creiamo il form in HTML, utilizzando questo codice:
<form action="sendmail.php" method="POST">
<b>Your name :</b> <input type="text" name="name"><br>
<b>Your e-mail :</b> <input type="text" name="email"><br>
<b>Message</b><br><textarea name="message"></textarea>
<input type="submit" value="Send"><input type="reset" value="Clear">
</form>
E' un semplice form mail con due caselle e un'area di testo.
Adesso creiamo in file di testo chiamato sendmail.php e inseriamo il seguente codice:
/*Here we are going to declare the variables*/
$name = $_POST['name'];
$email = $_POST['email'];
$message = $_POST['message'];
//Save visitor name and entered message into one variable:
$formcontent="VISITOR NAME: $name\n\nFEEDBACK: $message";
$recipient = "you@yourdomain.com";
$subject = "Contact Form";
Logicamente you@yourdomain.com corrisponde al nostro indirizzo email, e va quindi modificato. Se vuoi che la mail venga inviata a più di un indirizzo, è sufficiente mettere una virgola e in seguito l'altro/gli altri indirizzi.
Oltre all'email, possiamo cambiare l'oggetto del messaggio, modificando la variabile subject(Contact Form).
Continuando sul file sendmail.php, creiamo l'header del messaggio:
$mailheader = "From: $email\r\n";
$mailheader .= "Reply-To: $email\r\n";
$mailheader .= "MIME-Version: 1.0\r\n";
Dopo aver inserito l'header, aggiungiamo al file queste due righe di codice:
mail($recipient, $subject, $formcontent, $mailheader) or die("Failure");
echo "Thank You!";
Possiamo modificare il messaggio che comparirà in caso di mancato invio dell'email(Failure), oltre a quello che indica che la mail è stata inviata correttamente(Thank You!).
Il risultato del file sendmail.php, completo, è questo:
<?php
/*Here we are going to declare the variables*/
$name = $_POST['name'];
$email = $_POST['email'];
$message = $_POST['message'];
//Save visitor name and entered message into one variable:
$formcontent="VISITOR NAME: $name\n\nFEEDBACK: $message";
$recipient = "you@yourdomain.com";
$subject = "Contact Form";
$mailheader = "From: $email\r\n";
$mailheader .= "Reply-To: $email\r\n";
$mailheader .= "MIME-Version: 1.0\r\n";
mail($recipient, $subject, $formcontent, $mailheader) or die("Failure!");
echo "Thank You!";
?>
Articolo liberamente tradotto da http://www.codetricks.com/article.php?cat=phpmysql&id=11

Mandare un mail in CC o BBC
$target = "to_email_address";
$subject = "subject_email";
$text = "email_message";
// Questa sono le righe che funzionano da
// intestazione alla mail
$header = "From: vostra@mail.it
Reply-To: vostra@mail.it
X-Mailer: PHP/4.0.2
bcc: indirizzo@dichivuoi.it, indirizzo2@dichivuoi.it
cc: indirizzo@veditu.it, indirizzo2@veditu.it";
// Le ultime due righe mandano la mail in CC o in BCC
// Funzione mail!
mail ($target,$subject,$text,$header);
?>
Per mandare un mail in CC o in BCC basta inserire due nuove righe nell'header della mail.
La differenza tra BCC e CC, è che in BCC i vari destinatari non possono visualizzare gli altri utenti a cui è stata mandata l'e-mail, invece in CC sì.
Come spedire un' e-mail in formato HTML
$target = "to_email_address";
$subject = "subject_email";
$text = "email_message";
// Questa sono le righe che funzionano da
// intestazione alla mail
$header = "From: vostra@mail.it
Reply-To: vostra@mail.it
X-Mailer: PHP/4.0.2
Content-Type: text/html";
// Funzione mail!
mail ($target,$subject,$text,$header);
?>
Questo semplice codice spiega come spedire una mail in formato HTML. Tutto lo script sta nel Content-Type: text/html che definisce il formato della mail. E' ovvio che la variabile $text deve contenere codici HTML, o lo script risulta del tutto inutile!

Scrivere il contenuto di una variabili in un file
// Come inserire un dato in un file!
function Write_to_file($text) {

$file = "file.txt";
$connect = @fopen($file, "a");
fputs($connect, $text.';', "4096");
fclose($connect);
echo 'Scrittura sul file avvenuta correttamente';
}
Write_to_file("Ciao a tutti!");
?>
Questo script scrive il contenuto della variabile $text alla fine di un file di testo file.txt, separando i vari valori con il simbolo ( ; ). Questo può essere cambiato secondo le proprie esigenze.
Il valore della funzione fputs (4096) indica il numero di byte (o di caratteri) memorizzabili in quel ciclo. Se volete aggiungere più caratteri nel file, cambiate questo valore.
Occhio: non troppo grande, altrimenti piantate il Web Server!

Trasferire un file tramite FTP
Obiettivo
In questo articolo tratteremo come trasferire un file tramite ftp.
Articolo
Trasferire i dati con ftp e' come fare l'upload di file, ma mentre con l'upload i file sono passati tramite il protocollo http, qui sono passati tramite il protocollo ftp.
Come prima cosa dobbiamo settare server,user e password per accesso allo spazio ftp. Supponedo che il nostro spazio sia www.pippo.it
$ftp_server = "ftp.pippo.it";
$ftp_user_name = "";
$ftp_user_pass = "";
Poi identifichiamo il nome del file che vogliamo passare e il nome che questo file dovrà assumere sul server
$local_file = 'file.zip';
$destination_file = 'file.zip';
Ci connettiamo al server tramite
$conn_id = ftp_connect($ftp_server);
che ritorna 1 in caso di successo altrimenti 0. Ci colleghiamo al server
$login_result = ftp_login($conn_id, $ftp_user_name, $ftp_user_pass);
che ritorna 1 in caso di successo altrimenti 0. Tasferiamo il file in modalita' "FTP_ASCII"
if (ftp_put($conn_id, $destination_file, $local_file, FTP_ASCII)) {
e poi chiudiamo la connessione
ftp_close($conn_id);
Codice
<?php
$ftp_server = "ftp.pippo.it";
$ftp_user_name = "";
$ftp_user_pass = "";
$local_file = 'file.zip';
$destination_file = 'file.zip';
// cerca di connettersi
$conn_id = ftp_connect($ftp_server);
// Check open
if ((!$conn_id)) {
echo "Ftp-connect failed!"; die;
} else {
echo "Connected.";
}
// cerca di collegarsi
$login_result = ftp_login($conn_id, $ftp_user_name, $ftp_user_pass);
// Check colleg
if ((!$login_result)) {
echo "Ftp-colleg failed!"; die;
} else {
echo "Connected.";
}
// trasferisce il file
if (ftp_put($conn_id, $destination_file, $local_file, FTP_ASCII)) {
echo "$local_file trasferito\n";
} else {
echo "errore durante il trasferimento di $local_file\n";
}
// chiude la connessione
ftp_close($conn_id);
?>

Banner Rotating System with PHP
For the PHP people out there I converted the ColdFusion weighted rotating banner system. It is two files. Here is the first. I called it banner.php. You can call this file from a SSI include and it will run. The PHP and ColdFusion versions both do exactly the same thing in the same way just written for the different languages. Your database needs to be designed like so.
 
Field Name Type Description
ID Integer Auto incrementing
BANNER_ALT Text Alt description
BANNER_PIC Text Picture location
BANNER_URL Text URL link for banner
BANNER_WEIGHT Integer A weight from 0-10
BANNER_CLICKS Number How many times clicked
BANNER_VIEWS Number How many times viewed

<?php
$dbname = "<--database_name-->"
@ $db = mysql_connect("<--localhost-->", "<--username-->","<--password-->");
if (!$db)
{ echo "Error: Could not connect to DB.";
exit;}

// -- Start Banner Array --
$query = "select * from banners order by ID asc";
$results = mysql_db_query ($dbname,$query,$db);
//$prodlist = array ();
while ($row = mysql_fetch_array($results)){
for ($x=1; $x <= $row[banner_weight];$x++)
{$prodlist[] = $row[id];}
}
srand ((double) microtime() * 1000000);
$magicnumb = rand(0, count($prodlist)-1);
$magicnum = $prodlist[$magicnumb];
// -- End Banner Array --
// -- Start Banner View --
$query2 = "select * from banners where id = $magicnum";
$results2 = mysql_db_query ($dbname,$query2,$db);
while ($row2 = mysql_fetch_array($results2))
{
$add = $row2[banner_views] + 1;
$query3 = "update banners set banner_views = $add where id = $row2[id]";
mysql_db_query ($dbname,$query3,$db);
print "<br>";
// -- End Banner View --
// -- Start Display Banner --
print "<A HREF=\"banner/redirect.php?id=$magicnum\" TARGET=\"_blank\">";
print "<IMG SRC=\"$row2[banner_pic]\" alt=\"$row2[banner_alt]\" width=\"468\" height=\"60\"></A>";
// -- End Display Banner --
}
mysql_close ($db);
?>


The second file I called redirect.php. This page will add 1 to the click value for the banner in the database and then redirect to that site.


<?php
// -- Redirect Script --
$dbname = "<--database_name-->"
@ $db = mysql_connect("localhost", "<--username-->","<--password-->");
if (!$db)
{ echo "Error: Could not connect to DB.";
exit;}

// -- Start add one to Clicks --
$query = "SELECT * FROM banners where id = $id";
$results = mysql_db_query ($dbname,$query,$db);
while ($row = mysql_fetch_array($results)){
$add = $row[banner_clicks] + 1;
$query2 = "UPDATE banners set banner_clicks = $add where id = $row[id]";
mysql_db_query ($dbname,$query2,$db);
// -- End add one to Clicks --
// -- Start Redirect --
print "<META HTTP-EQUIV=\"Refresh\" Content=\"0; URL=http://$row[banner_url]\">";
}
// -- End Redirect --
mysql_close ($db);
?>

Leggere e scrivere su file
Quandi si realizzano degli script quasi sempre si ha necessita' di salvare i dati che vengono inseriti dagli utenti. Le strade che si possono seguire in questo caso sono due:
- Salvare i dati su file (ad esempio di estensione .txt, .dat, ecc..)
- Salvare i dati su database(ad esempio Access, Mysql, ecc..)
Salvare dati su file è conveniente quando la quantità di dati da salvare non è elevata e quando non si dispone di un database, se invece la quantità di dati da salvare è elevata, salvare i dati su database è la soluzione migliore in quanto manipolare i dati salvati così risulta più semplice e pratico. Ora soffermiamoci sul discorso dei file e vediamo come scrivere e leggere dati su un file di testo di nome "pippo.txt".
Ora nella pagina successiva andremo a vedere come scrivere su file.
Scrittura su file:
Per poter scrivere su file bisogna innanzitutto aprirlo. Utilizzeremo quindi la seguente istruzione:
$scrivi_file=fopen("pippo.txt","w");
$scrivi_file viene chiamato puntatore di apertura del file. fopen prende come primo argomento il nome del file e come secondo argomento la modalità di apertura del file. La "w" indica che si vuole aprire il file pippo.txt in modalità scrittura.
Le altre modalità per aprire un file hanno i seguenti simboli:
"r" -> apre il file in sola lettura;
"r+" -> apre il file in lettura ed in scrittura;
"w" -> apre il file in sola scrittura;
"w+" -> apre il file in lettura e scrittura;
"a" -> apre il file in sola scrittura e inserisce il puntatore alla fine del file ("w" lo inserisce all'inizio)
"a+" -> apre il file in lettura e scrittura inserendo il puntatore alla fine del file;
Dopo aver aperto il file ci scriviamo i dati dentro. Supponiamo di volere scrivere nel file la stringa "messaggio di prova":
$stringa="messaggio di prova";
fwrite($scrivi_file,$stringa);
fclose($scrivi_file);
L'istruzione fwrite ha il compito di scrivere nel file la stringa $stringa. Egli prende come primo argomento il puntatore di apertura del file $scrivi_file che avevamo visto in precendenza e come secondo argomento la stringa che vogliamo memorizzare nel file. Una volta memorizzata la stringa nel file possiamo terminare l'interazione con il file con l'istruzione fclose che prende come argomento il puntatore di apertura del file. Nella pagina successiva andremo a vedere come leggere sul file la stringa che abbiamo memorizzato.
Lettura su file:
Ora andiamo a leggere nel file pippo.txt la stringa di testo che ci abbiamo memorizzato. Le istruzioni da digitare seguono la stessa logica delle istruzioni pr scrivere su file. Per prima cosa voglio aprire il file:
$leggi_file=fopen("pippo.txt","r");
Il puntatore di apertura del file l'abbiamo chiamato questa volta $leggi_file. Al puntatore gli è associata l'istruzione fopen che abbiamo già incontrato nella scrittura su file. Ora andiamo a leggere ciò che è contentuto nel file.
$dim_file=filesize("pippo.txt");
$contenuto=fread($leggi_file,$dim_file);
fclose($leggi_file);
L'istruzione fread che legge il contenuto del file vuole come primo argomento il puntatore di apertura del file e come secondo argomento la quantità di dati (in bytes) che si vuol leggere. Supponiamo di voler leggere tutto il contenuto del file, perciò utilizziamo l'istruzione filesize che prende come argomento il file di cui si vuole sapere le dimensioni (in bytes) e assegniamo questo valore alla variabile $dim_file.
Il contenuto letto dall'istruzione fread lo memorizziamo nella variabile $contenuto, quindi chiudiamo l'interazione con il file con l'istruzione fclose già vista in precedenza per la scrittura. Abbiamo finito con le operazioni di scrittura e lettura su file. Se ora volete per esempio stampare su schermo ciò che era contenuto nel file scrivete l'istruzione:
echo $contenuto;
Vi apparirà su schermo la scritta 'Messaggio di prova' che avevate memorizzato su file. Nella pagina successiva troverete il riepilogo di tutto ciò detto finora.
Riepilogo:
Riepilogando tutto ciò detto troverete qui sotto il codice per scrivere e leggere su file. Vi ricordo che i simboli // in php introducono un commento.
// Stringa da scrivere su file
$stringa="Messaggio di prova";
// Scrittura del file
$scrivi_file=fopen("pippo.txt","w");
fwrite($scrivi_file,$stringa);
fclose($scrivi_file);
// Lettura del file
$leggi_file=fopen("pippo.txt","r");
$dim_file=filesize("pippo.txt");
$contenuto=fread($leggi_file,$dim_file);
fclose($leggi_file);
//Stampa su schermo del contenuto del file
echo $contenuto;

Come ottimizzare le tabelle di un database MySQL
Queste poche righe di codice consentono di utilizzare OPTIMIZE TABLE, un programmino per ottimizzare le tabelle di un database MySQL(n.b. OPTIMIZE TABLE funziona solo con tabelle di tipo MyISAM o BDB).
Questo script è utile nel caso ci trovassimo ad utilizzare database di una certa grandezza, a cui abbiamo fatto aggiunte, cancellazioni o modifiche. Gli spazi vuoti verranno rimossi , e verrà riordinato l'indice del database stesso. Questo porterà consistenti guadagni in termini di spazio, velocità e prestazioni.

<?
$host = "host_database";
$user = "username";
$pass = "password";
$db_name = "nome_del_database";

$db = mysql_connect($host, $user, $pass);
mysql_select_db($db_name, $db);


echo "Ottimizzazione DataBase in corso...";
$SQL = "OPTIMIZE TABLE ";
$result = mysql_list_tables($DATABASE);
$i = 0;
while ($i < mysql_num_rows($result)) {
$name_table = mysql_table_name($result, $i);
echo "Ottimizzazione tabella: $name_table .....<BR>";
$SQL .= $name_table;
$SQL .= ",";
$i++;
}
$SQL = substr($SQL,0,strlen($SQL)-1);
$result_set = mysql_query($SQL);
mysql_free_result($result_set);

?>

Basterà creare un file con estensione .php, copiare ed incollare questo codice, ed eseguirlo periodicamente.
 

Gestiamo i database con PhpMyAdmin
PhpMyAdmin è un tool in PHP per la gestione dei database. Consente, grazie all'utilizzo di un pannello di controllo molto intuitivo, di creare, eliminare, modificare e gestire al meglio i database MySQL; creare, modificare, cancellare intere tabelle o singoli record; fare un backup dei dati contenuti nel database, e visualizzare informazioni sul db.
Per installarlo, scarichiamo l'ultima versione dal sito ufficiale, http://www.phpmyadmin.net/home_page/. Nella nuova versione, la 2.5.6, sono stati corretti alcuni bug di sicurezza e inserite alcune funzioni interessanti.
Dopo aver scaricato il pacchetto, decomprimiamolo in una cartella, e modifichiamo il file di configurazione config.inc.php.
Una volta aperto, modifichiamo le seguenti righe di codice:
$cfg['Servers'][$i]['host']
Questa variabile corrisponde all'host a cui dovrà connettersi PhpMyAdmin per accedere al database. Sostituiamo host con l'indirizzo del nostro database(es. sql.webmasterpoint.org)
$cfg['Servers'][$i]['port']
port invece va sostituito con la porta su cui lavora MySQL nella nostra macchina. Solitamente è la 3306
$cfg['Servers'][$i]['user']
L'username da utilizzare per connettersi al database
$cfg['Servers'][$i]['password']
La password da utilizzare per connettersi al database
$cfg['Servers'][$i]['controluser']
Nome utente che utilizzeremo per collegarci a PhpMyAdmin
$cfg['Servers'][$i]['controlpass']
Password che utilizzeremo per collegarci a PhpMyAdmin
Dopo aver completato la configurazione, accediamo a PhpMyAdmin tramite l'indirizzo www.vostronome.it/cartellaphpmyadmin/index.php, e iniziamo a lavorare con questo interessantissimo tool.
 

Immagine non disponibile
<body>
<center>
<table border="5" cellpadding="0" cellspacing="0" width="30%" bordercolorlight="#C0C0C0" bordercolordark="#008080">
<tr>
<td width="100%">
if immagine=""
echo "immagine non disponibile";
{
else
}
echo "xxxxx";
<p align="center"><img border="0" src="file:///f:/Documenti/001.jpg" width="65" height="65" ></p>

</td>
</tr>
</table>
</center>
width="100%" height="100%"
</body>

Proteggere una pagina con username e password
Con questo script php è possibile proteggere una pagina web, tramite username e password.
Lo script include un array che da la possibilità di impostare quattro username e altrettante password; è comunque possibile personalizzarlo ed aumentare il numero degli username disponibili.
Questo è il codice da utilizzare. E' sufficiente includerlo in una pagina con estensione .php
<?php
if(!isset($PHP_AUTH_USER))
{
Header("WWW-Authenticate: Basic realm=\"Xavier Protection\"");
Header("HTTP/1.0 401 Unauthorized");
echo "Text to send if user hits Cancel button\n";
exit;
}
else
{
$user_passwords = array (
"user1" => "password1",
"user2" => "password2",
"user3" => "password3",
"user4" => "password4"
);
if (($PHP_AUTH_USER == "") || ($PHP_AUTH_PW == ""))
{
Header("HTTP/1.0 401 Unauthorized");
echo "Sorry, could find your password!";
exit;
}
else if (strcmp($user_passwords[$PHP_AUTH_USER],$PHP_AUTH_PW) == 0)
{
echo "This is the password protected page.";
exit;
}
else
{
Header("HTTP/1.0 401 Unauthorized");
echo "Sorry, could find your password!";
exit;
}
}
?>
Come si può vedere analizzando il codice, la lista degli username e delle password viene gestita dall'array $user_passwords.
Per modificarli, basta cambiare le voci in grassetto; logicamente user1 corrisponderà a password1, user2 a password2, e così via.

Paginazione dei dati presenti in un file di testo senza uso di database
In questo tutorial si parla di una cosa che potrebbe interessare molto persone, soprattutto quelle che non hanno la possibilità di inserire i loro dati in bel database MySQL!
Infatti, ora vedremo come riuscire a paginare (ossia visualizzare un tot di dati per pagina) i dati presenti in un file di testo.
Come prima cosa, cominciamo a creare le variabili di configurazione, ecco il codice: 
$file = file("./file.txt");
if($perpage == FALSE) $perpage = 30;
if($pos == FALSE) $pos = 0;
$count = count($file);
Vediamo un pò che cosa vogliono dire quelle stringhe di codice:
La variabile $file serve appunto per selezionare il nostro file, $perpage per decidere quanti record visalizzare per pagina, $pos sta a indicare il numero della pagina e infine $count serve a vedere il numero totale dei record. 
Passiamo ora alla visualizzazione dei record.
Ecco il codice:
for($i = $pos; $i < ($perpage+$pos); $i++)
{
if($i > $count-1) break;
$result = explode("|", trim($file[$count-$i-1]));

echo "<li>$result[0] $result[1]\n";
}
Ora spieghiamo un pochino che cosa vuol dire quel insieme di simboli :)
Per prima cosa vorrei far notare il metodo usato per la visualizzazione dei records: si usa il ciclo for().
Questa parte (come la successiva) è totalmente personalizzabile inquanto si può decidere in che modo mostrare i nostri record, o al contrario, se non dovessero essercene.
In questa parte l'unica variabile da commentare è $result; anche questa variabile può essere leggermente modificata, o meglio... è possibile modificare il carattere separatore (che in questo caso è "|")
Come ultima cosa, vediamo come creare una specie di navigatore: con il codice sottostante è possibile scegliere che pagina visualizzare.
Vediamo come fare:
echo "<div align=\"center\">[ ";
for($p = 0; $p < $count; $p++)
{
if(!($p % $perpage))
{
$pg = ($p/$perpage)+1;
if ($p == $pos)
{
echo "<strong>$pg</strong> ";
}
else
{
echo "<a href=\"?pos=$p\">$pg</a> ";
}
}
}
echo " ]</div>";
In questa parte c'è davvero poco da dire.
L'unica cosa che è possibile modificare è il modo di visualizzazione delle pagine.
Ma questo sta alla vostra fantasia... :))
Ecco a voi il codice completo:
<?php
$file = file("./file.txt");
if($perpage == FALSE) $perpage = 30;
if($pos == FALSE) $pos = 0;
$count = count($file);
for($i = $pos; $i < ($perpage+$pos); $i++)
{
if($i > $count-1) break;
$result = explode("|", trim($file[$count-$i-1]));

echo "<li>$result[0] $result[1]\n";
}

echo "<div align=\"center\">[ ";
for($p = 0; $p < $count; $p++)
{
if(!($p % $perpage))
{
$pg = ($p/$perpage)+1;
if ($p == $pos)
{
echo "<strong>$pg</strong> ";
}
else
{
echo "<a href=\"?pos=$p\">$pg</a> ";
}
}
}
echo " ]</div>";
?>

Usare i cookies con PHP
Introduzione
Un cookie è un blocco di informazioni generato dal web server e immagazzinato nel computer dell'utente.
I dati dei cookies vengono trasmessi con il resto delle intestazioni HTTP.
Così come altre intestazioni, i cookies devo essere trasmessi prima di qualsiasi altro output dal vostro script (questa è una limitazione di protocollo per le intestazioni).
Se l'output esiste prima di chiamare questa funzione, la creazione del cookie fallisce e darà come valore di ritorno FALSE.
Questo tutorial presuppone la conoscenza di alcune cose da parte dell'utente:
* Familiarità con PHP
* Avere l'accesso al server o ai server su cui funziona il pacchetto PHP.
Per prima cosa analizziamo i principi fondamentali dei cookies dopodiché passeremo alla pratica.
Settare il cookie
Per creare un cookie si usa la funzione setcookie():
boolean setcookie ( string name [, string value [, int expire [, string path [, string domain [, int secure]]]]] )
Tutti gli argomenti della funzione setcookie() sono facoltativi, tranne il nome (name).
Se la funzione contiene solo, come argomento, il nome, il cookie con quel nome verrà cancellato dal client remoto.
E' anche possibile sostituire qualunque argomento con una stringa vuota (""), per saltare l'argomento stesso.
Gli argomenti "expire" e "secure"sono numeri interi e non possono essere saltati utilizzando una stringa vuota, ma deve essere invece usato uno zero (0).
L'argomento "expire" è un numero intero di indicazione del tempo e viene richiamato dalle funzioni time() e mktime().
L'argomento "secure" indica che il cookie deve essere trasmesso tramite una sicura connessione http.
Questa funzione restituirà un valore booleano TRUE in caso di successo dell'esecuzione della funzione oppure un valore FALSE in caso contrario.
Notate che il valore booleano di ritorno non è influenzato dall'accettazione o dalla non accettazione del cookie da parte del browser dell'utente.
01 <?php 
02 $time = time(); 
03 if (!isset($cookie_data)) { 
04 $f_name = "John"; 
05 $l_name = "Miller"; 
06 $visits = 1; 
07 $cookie_string = $f_name.'&'.$l_name.'&'.$visits; 
08 setcookie ("cookie_data",$cookie_string, $time+3600); 
09 echo "Your cookie has been set."; 
10 } 
11 ?> 
In questo nostro esempio, ho dato dei valori alle variabili "name".
Nella maggior parte dei casi, questo deriva dall'input dell'utente.
Usando questi valori, creiamo un cookie se non esiste già.
Facciamo questo, costruendo una stringa che contiene tutti gli elementi di un cookie data; dopodiché assegniamo un valore alla stringa, con un limite di tempo.
Leggere il cookie
Prendiamo l'esempio precedente e cerchiamo di elaborarlo:
01 <?php 
02 $time = time(); 
03 if (isset($cookie_data)) { 
04 $cookie_info = explode("&", $cookie_data); 
05 $f_name = $cookie_info[0]; 
06 $l_name = $cookie_info[1]; 
07 $visits = $cookie_info[2]; 
08 $visits ++; 
09 $cookie_string = $f_name.'&'.$l_name.'&'.$visits; 
10 setcookie ("cookie_data",$cookie_string, $time+3600); 
11 echo "Welcome back $f_name $l_name, this is visit number: $visits"; 
12 } else { 
13 $f_name = "John"; 
14 $l_name = "Miller"; 
15 $visits = 1; 
16 $cookie_string = $f_name.'&'.$l_name.'&'.$visits; 
17 setcookie ("cookie_data",$cookie_string, $time+3600); 
18 echo "Your cookie has been set."; 
19 } 
20 ?> 
Questo script è composto da tre parti:
1. la funzione "Explode" divide la stringa di dati del cookie in elementi più piccoli
2. il contatore viene incrementato e un nuovo cookie conterrà le informazioni aggiornate
3. vengono rimandati all'utente i dati rilevanti
I cookies non diventeranno visibili fino al successivo caricamento della pagina, nella quale il cookie è stato settato per essere visibile.
Chiamate multiple a SetCookie, nello stesso script, verranno effettuate in ordine inverso.
Distruggere il cookie
Per distruggere un cookie basta fissare la data di scadenza ad un certo tempo nel passato.
Così facendo, verrà detto al browser che il cookie sarebbe dovuto esistere in una data passata e quindi si innescherà il meccanismo di rimozione del cookie nel vostro browser.
1 <?php 
2 $time = time(); 
3 if (isset($cookie_data)) { 
4 setcookie ("cookie_data", "", $time - 3600); 
5 } 
6 ?> 
Conclusione
Lavorare con i cookies è abbastanza semplice e PHP ci viene in aiuto con delle semplici funzioni, come per esempio setcookie().
Saper creare, leggere e cancellare i cookies può inoltre servirci per svariati scopi, come per esempio tenere traccia degli utenti del nostro sito web.

Gestione Permessi
Come detto in precedenza, MySQL offre una gestione dei permessi molto flessibile ed efficiente. Le nuove versioni permettono anche di limitare le risorse utilizzabili da un utente o di attivare solo l'accesso protetto, tramite SSL, al database. Quest'ultima caratteristica è importante utilizzarla quando si da accesso esterno a dei client che trattano dati riservati presenti nei database a cui si ha accesso.
Per la gestione dei permessi è possibile: 
utilizzare i comandi GRANT e REVOKE, per dare o revocare permessi ad un utente 
inserire, modificare o eliminare i record dalle tabelle apposite presenti nel database mysql 
Come per la gestione utenti, tratteremo soltanto il primo metodo.
L'elenco di permessi disponibile varia da versione a versione, i vari esempi sono stati testati su MySQL 4.0 e superiori, quindi, se non dovessero funzionare accertatevi che state utilizzando una versione pari o superiore ad una 4.0 di MySQL. 
I privilegi fondamentali, ovvero quelli più usati, sono: 
SELECT, per dare la possibilità ad un utente di leggere dei dati 
INSERT, per permettere l'inserimento di record 
UPDATE, che abilita l'utente a modificare i dati presenti nei record delle tabelle 
DELETE; che permette di eliminare i record
I permessi, combinati tra loro, possono dare la possibilità di eseguire altri comandi, che non hanno un permesso diretto, ma derivato, ovvero che le operazioni che andrà a svolgere il comando saranno attivabili solo quando l'utente che lo esegue ha una serie ben precisa di permessi.
Altri permessi molto utili sono: 
CREATE, che permette di creare entità come DATABASE o TABELLE. Se viene abilitato il permesso a livello GLOBALE, il CREATE, permetterà la creazione di DATABASE e TABELLE, mentre se viene abilitato a livello DATABASE, verrà soltanto abilitata la creazione di TABELLE in quello specifico database. 
DROP, da la possibilità di eliminare DATABASE o TABELLE. Vale quanto detto per il privilegio CREATE.
Se al nostro utente myuser volessimo adesso dare accesso in lettura, scrittura e modifica ai dati del database test dovremmo eseguire:
GRANT SELECT, INSERT, UPDATE ON test.* TO myuser@localhost 
Per disabilitare, invece, la possibilità dell'utente di modificare ed inserire records, basterebbe digitare:
REVOKE INSERT, UPDATE ON test.* FROM myuser@localhost 
Attenzione, è importante utilizzare sempre la stessa accoppiata nome utente e host, altrimenti verrà creato un nuovo utente o ne verrà modificato un altro rispetto a quello sul quale si ci vuole agire.
Links utili 
Esistono tantissimi guide che trattano questi argomenti, ma vi consiglio di leggere ciò che dice il manuale di MySQL in proposito: 
Guida ai comandi GRANT e REVOKE, con relativo elenco dei permessi (http://dev.mysql.com/doc/mysql/en/grant.html)
Amministrazione di MySQL (http://dev.mysql.com/doc/mysql/en/mysql-database-administration.html)
Come funzionano i privilegi su MySQL (http://dev.mysql.com/doc/mysql/en/privilege-system.html)
Limitare le risorse di un account (http://dev.mysql.com/doc/mysql/en/user-resources.html)
Utilizzare connessioni sicure (http://dev.mysql.com/doc/mysql/en/secure-connections.html)

Gestione Utenti
Creare utenti in MySQL è molto semplice, e, molto spesso, il client di amministrazione supporta queste funzionalità, ma è bene sapere com'è possibile gestirli da MySQL.
Per aggiungere, modificare o rimuovere un utente ci sono due sistemi: 
Il primo consente di creare, disabilitare e modificare gli utenti, le password e i permessi con una sola query, tramite l'utilizzo dei comandi GRANT e REVOKE. Questo sistema, però, non permette di rimuoverli, ma solo di disabilitarli. 
Il secondo, sicuramente più lungo e complesso, permette di capire, bene, come MySQL gestisce le informazioni all'interno
Di seguito tratteremo soltanto il primo sistema per gestire gli utenti.
La sintassi di GRANT è la seguente:
GRANT priv_type [(column_list)] [, priv_type [(column_list)]] ...
ON {* | *.* | db_name.* | db_name.tbl_name}
TO user [IDENTIFIED BY [PASSWORD] 'password']
[, user [IDENTIFIED BY [PASSWORD] 'password']] ...
Per utilizzare l'istruzione GRANT è quindi necessario elencare i permessi da dare all'utente, e questi possono essere: 
a livello GLOBALI, quando nella clausola ON viene specificato *.* 
a livello di DATABASE, quando nella clausola ON viene impostato nome_database.* 
a livello di TABELLA; quando viene utilizzato nella clausola ON nome_database.nome_tabella 
La gestione dei permessi sarà trattata nel paragrafo successivo, al momento utilizzeremo soltanto il privilegio ALL, che comprende tutti i privilegi che possono essere acquisiti da un utente.
La clausola TO permette di impostare quale deve essere l'utente che deve ricevere i permessi e supporta. Inoltre è anche possibile cambiare la password di accesso direttamente utilizzando IDENTIFIED BY 'nuova_password'.
Ovviamente si possono specificare più permessi ed è anche possibile specificare più utenti, ed a ogni utente è possibile impostare una password diversa. Nel caso vengano inseriti più utenti, questi riceveranno tutti gli stessi permessi. È anche possibile indicare da quale host l'utente si può connettere, inserendo @nome_host subito dopo il nome utente. Se non verrà impostato l'host l'utente potrà connettersi da qualsiasi host.
Se, ad esempio, vogliamo creare l'utente myuser, impostando la password a mytest, e a questo vogliamo dare accesso solo al database test, basterà digitare:
GRANT ALL ON test.* TO myuser@localhost IDENTIFIED BY 'mytest'; 
Come detto in precedenza è possibile eliminare gli utenti o revocare i permessi tramite il comando REVOKE:
REVOKE priv_type [(column_list)] [, priv_type [(column_list)]] ...
ON {* | *.* | db_name.* | db_name.tbl_name}
FROM user [, user] ...
Come per il comando GRANT, tratteremo la gestione dei permessi nel paragrafo successivo. 
Per eliminare un utente è sufficiente revocargli tutti i permessi da tutti i database a cui ha accesso. Per questo comando vale quanto detto per il comando GRANT, con l'unica differenza sulla clausola FROM, nella quale è presente l'elenco di utenti ai quali revocare i permessi. Anche qui, se nel nome utente è presente @nome_host, verranno revocati i permessi ad uno specifico utente che può accedere dall'host passato.
Se volessimo disabilitare l'utente myuser possiamo revocare i permessi tramite
REVOKE ALL ON test.* FROM myuser@localhost; 
In questo modo l'utente user, sebbene fisicamente ancora esistente, è praticamente disabilitato, poiché non può accedere a nessun database, in nessun modo.

Gestione di Database
Creare un database su MySQL è molto semplice semplice e basta una sola riga di comando:
CREATE DATABASE [IF NOT EXISTS] db_name 
Com'è possibile intuire, il comando non fa altro che dire a MySQL di creare il database di nome db_name. Ovviamente al posto di db_name va inserito il nome del database da creare, altrimenti verrà creato il database db_name. Nel comando è possibile specificare la clausola IF NOT EXISTS, la quale indica al server di creare il database soltanto se questo non esiste già.
Eliminare database è altrettanto semplice:
DROP DATABASE [IF EXISTS] db_name 
Anche qui db_name corrisponde al nome del database da eliminare. Come per l'istruzione CREATE DATABASE, è presente una clausola che indica a MySQL di eliminare il database solamente se esiste, ovvero IF EXISTS.
Le clausole IF NOT EXISTS, di CREATE DATABASE, e IF EXISTS, di DROP DATABASE, sono molto utili quando si preparano blocchi di query da eseguire, infatti, se il database dovesse esistere già, o non dovesse esistere, nel caso di DROP TABLE, si riceverebbe un errore e quindi l'esecuzione delle query verrebbe immediatamente interrotta mentre, utilizzando queste clausole, non verrà restituito nessun errore e queste istruzioni verranno processate senza alcun problema.

Gestire database, utenti e permessi con MySQL
(http://freephp.html.it/articoli/view_articolo.asp?id=166)
Tanti di voi si saranno ritrovati nella situazione di dover creare utenti o database, di dover permettere l'accesso di alcuni utenti a dei specifici database, senza poter agire sugli altri, o ancora di dover dare l'accesso ad uno script o ad un client per l'amministrazione dall'esterno al server MySQL.
Questo RDBMS ha una gestione estremamente flessibile e nello stesso tempo semplice per quanto riguarda l'amministrazione di database e utenti e dei relativi permessi. MySQL permette la gestione dei permessi nel dettaglio, è infatti possibile specificare, colonna per colonna, cosa l'utente può fare o non può fare.
L'articolo non vuole essere una spiegazione dettagliata di come gestire database, utenti e permessi di questi, ma soltanto un'introduzione per chi si trova a dover lavorare con questo software per la prima volta.
Requisiti
È necessario avere installato un server Myql, ed un client di accesso, come phpMyAdmin, MySQL-Front o altri, per poter eseguire delle query sul server.
È comunque possibile utilizzare il client da linea di comando di MySQL, che si chiama mysql, che trovate su windows nella cartella bin della cartella d'installazione di MySQL, su Linux, invece, dovrebbe essere possibile richiamarlo direttamente da console se lo avete installato tramite un pacchetto RPM, DEB, TGZ, o altri in base alla distribuzione, altrimenti, come per Windows, l'eseguibile è disponibile all'interno della cartella bin presente nella cartella di installazione di MySQL.

MySQL: gestione delle tabelle
(http://freephp.html.it/articoli/view_articolo.asp?id=171)
(http://freephp.html.it/articoli/view_articolo.asp?id=172)
Chi usa database avrà avuto spesso la necessità di creare, eliminare e modificare tabelle.
Quest'articolo, suddiviso in due parti, tratterà la completa gestione delle tabelle in MySql, ovvero i comandi SQL per creare, eliminare e alterare tabelle, le tipologie di tabelle, la gestione degli indici ed altro ancora.
In questa prima parte spiegheremo come creare, eliminare e rinominare le tabelle.
Creare tabelle
Il comando CREATE TABLE e' usato su MySql (come anche su tutti i database che rispettano lo standard SQL) per definire come le tabelle devono essere create. 
La sintassi del comando è la seguente: 
CREATE [TEMPORARY] TABLE [IF NOT EXISTS] tbl_name
[(create_definition,...)]
[table_options]
MySql supporta la possibilità di creare tabelle temporanee ovvero tabelle che esistono solo per la connessione corrente, usando la clausola TEMPORARY nell'istruzione CREATE TABLE. E' importante notare che queste tabelle verranno automaticamente eliminate al momento della chiusura della connessione da parte del client, e, che nel caso di connessioni persistenti, le tabelle temporanee rimarranno visibili anche agli script che faranno uso di quelle connessione. L'istruzione CREATE TABLE supporta anche la clausola IF NOT EXIST, che come dice il nome stesso, fa si che la tabella venga creata solamente se questa non esiste e quindi evitando errori. Per creare una tabella è necessario definire l'elenco di colonne ed indici che questa conterrà. 
Ogni colonna può essere strutturata come riportata qui di seguito 
col_name type [NOT NULL | NULL] [DEFAULT default_value]
[AUTO_INCREMENT] [UNIQUE [KEY] | [PRIMARY] KEY]
[COMMENT 'string']
Il paramentro col_name corrisponde al nome della colonna, mentre type al tipo di dato. Per i tipi di colonna è possibile visitare la documentazione ufficiale di MySql all'indirizzo: http://dev.mysql.com/doc/mysql/en/column-types.html 
Gli indici delle tabelle sono importanti perché determinano l'efficienza e la velocità di lettura dei dati.
Esistono 3 tipi di indici:
- PRIMARY KEY, indici che permettono di definire quale campo o quali campi identificano in maniera univoca una riga della tabella. Il valore (o la combinazione dei valori) può essere presente una sola volta.
- UNIQUE KEY, chiavi che permettono di definire delle colonne come uniche e quindi, come per le PRIMARY KEY, i valori non possono ripetersi.
- INDEX KEY, indici che permettono di eseguire ricerche più veloci sulla colonna o sulle colonne specificate.
E' anche possibile definire una colonna che appartiene alla PRIMARY KEY come AUTO INCREMENT ottenendo quindi che la colonna contenga un valore progressivo che aumenterà all'inserimento di ogni riga e che sarà univoco per quella riga. 
MySql supporta svariati tipi di tabelle, le più importanti sono:
- MyIsam, usati di default in MySql per le loro caratteristiche di efficienza e compattezza
- INNODB, utili per le feature che mettono a disposizione, ovvero le transazioni e le chiavi esterne
- HEAP, o Memory, che, per via della propria natura, permettono l'esecuzione velocissima delle istruzioni SQL, infatti questo tipo di tabelle sono interamente gestite in memoria. E' importante ricordare che queste tabelle vengono svuotate al riavvio di MySql, quindi possono contenere soltanto dati volatili
CREATE TABLE libri (
id INT(10) NOT NULL AUTO_INCREMENT,
autore VARCHAR(255) NOT NULL,
titolo VARCHAR(255) NOT NULL,
costo FLOAT(10,2) NOT NULL,
PRIMARY KEY (id)
) TYPE=MyISAM 
Con quest'istruzione verrà creata una tabella di nome libri contenente 4 campi, id, autore, titolo e costo, e il campo id impostato come chiave primaria autoincrement. 
Eliminare tabelle
Eliminare tabelle su MySql è estremamente semplice, è infatti possibile usare per lo scopo il comando DROP TABLE. 
DROP [TEMPORARY] TABLE [IF EXISTS]
tbl_name [, tbl_name] ...
Com'è possibile vedere anche questo comando supporta la clausola IF EXISTS che permette di evitare errore in caso di tabella mancante.
A partire di MySql 4.1 è possibile usare la parola chiave TEMPORARY per eliminare le tabelle temporanee.
Il parametro tbl_name corrisponde al nome della tabella che si vuole eliminare.
Si possono anche eliminare più tabelle con un sol comando: è sufficente separarne i nomi con una virgola. 
DROP TABLE tbl1, tbl2, tbl3 
Con l'esempio sopra riportato si eliminerebberò 3 tabelle, tbl1, tbl2 e tbl3, con una sola istruzione SQL. 
Rinominare tabelle
Come per l'eliminazione, rinominare una tabella è estremamente semplice:
RENAME TABLE tbl_name TO new_tbl_name
[, tbl_name2 TO new_tbl_name2] ...
Il parametro tbl_name corrisponde al nome della tabella che si deve rinominare mentre new_tbl_name al nuovo nome. Anche con questo comando è possibile rinominare più tabelle contemporaneamente separando semplicemente questi blocchi di nomi con una virgola 
RENAME TABLE tbl1 TO tmp_tbl1,
tbl2 TO tbl1,
tmp_tbl1 TO tbl2;
Se ad esempio si volessero scambiare i nomi di due tabelle, tbl1 e tbl2, basterebbe lanciare il comando RENAME TABLE facendogli eseguire 3 scambi, utilizzando un nome temporaneo per una delle due tabelle e poi rinominando le tabelle per come serve. 
Approfondimenti Per chi volesse avere informazioni più dettagliate sull'argomento può andare sul manuale ufficiale di MySql a quest'indirizzi:
http://dev.mysql.com/doc/mysql/en/create-table.html
http://dev.mysql.com/doc/mysql/en/drop-table.html
http://dev.mysql.com/doc/mysql/en/rename-table.html
Cosa sono gli Indici
Gli indici sono la parte più importante della tabella, ne influenzano la dimensione e determinano la velocità di ricerca e quella di inserimento, di modifica ed eliminazione.
Un indice non è altro che un elenco di valori (o record) che indicano al database, in questo caso a MySql, dove si trova la riga che contiene ciò che cerchiamo: in parole semplici, facendo ricerche su campi impostati come indici la velocità delle query aumenta notevolmente ma, al tempo stesso, rallenta quando questi dati devono essere inseriti, modificati o eliminati.
Troppi indici causerebbero un eccessivo rallentamento nelle operazioni di modifica dell'elenco, troppo pochi comporterebbero un rallentamento eccessivo nella ricerca dei dati, che molto spesso avviene con maggiore frequenza, ed è quindi fondamentale impostarli bene per ottenere una tabella che funzioni bene.
Il tipo di indice usato influenza notevolmente la velocità delle operazioni, infatti un indice di tipo unico permette a MySql di recuperare i dati più velocemente di un indice normale perché l'indice unico assicura al database che può esserci un solo record associato a quel valore (la cosa cambia se nella ricerca è usato LIKE al posto dell'operatore.
Come detto nella prima parte esistono 3 tipi di indici: 
PRIMARY KEY, chiamate anche PK, che, oltre ad essere chiavi uniche, forzano il database a organizzare i dati in base ai valori contenuti nelle colonne usate nell'indice 
UNIQUE KEY, come dice il nome, chiavi uniche 
INDEX KEY, chiavi senza nessun attributo speciale
Da notare che usando le Primary Key è possibile definire una ed una sola colonna della tabella, impostata come Primary Key, come Auto Increment, ovvero un valore che si incrementa da solo (il tipo del campo deve essere numerico). Inoltre gli indici possono essere applicati a più colonne contemporaneamente. In questo caso gli attributi dell'indice varranno per l'insieme delle colonne usate.
È estremamente consigliato, quando si fanno inserimenti in massa, di rimuovere e poi riaggiungere, al termine dell'operazione, gli indici della tabella in modo da far lavorare di meno MySql: mentre con un inserimento di massa vi sono svariate istruzioni INSERT che vengono eseguite separatamente e quindi gli indici vengono aggiornati ad ogni esecuzione, l'eliminazione e la successiva riaggiunta degli indici forzerà il database a ricreare l'elenco una sola volta.
Gestione degli Indici
La gestione degli indici può essere fatta in svariati modi: 
Al momento della creazione della tabella 
Tramite il comando sql ALTER TABLE, del quale parleremo nel paragrafo successivo
Inoltre è anche possibile utilizzare degli alias speciali di ALTER che permettono l'inserimento dell'indice senza ricorrere a quest'ultimo, ovvero: 
CREATE INDEX, crea un indice 
DROP INDEX, elimina un indice
Le rispettive sintassi sono riportate di seguito: 
CREATE [UNIQUE] INDEX index_name
ON tbl_name (index_col_name,...)
index_col_name:
col_name [(length)]
Com'è possibile vedere, è indispensabile dare un nome all'indice, tramite il parametro index_name, ed è necessario definire la tabella sul quale questo verrà creato. Inoltre è anche necessario definire l'elenco delle colonne che appartengono all'indice.
Per le colonne di tipo VARCHAR e CHAR nell'indice è possibile usare anche il parametro lenght in modo da indicizzarne solo una parte, mentre per i tipi BLOB, TEXT e simili è obbligatorio specificarne la lunghezza.
DROP INDEX index_name ON tbl_name 
La sintassi del comando DROP INDEX è molto più semplice, infatti richiede soltanto il nome dell'indice da eliminare ed il nome della tabella alla quale appartiene l'indice.
Il comando ALTER TABLE
Questo comando, come suggerisce il nome, permette l'alterazione, ovvero la modifica, delle tabelle. Tramite il comando ALTER TABLE è infatti possibile non soltanto gestire le informazioni sulla tabella, come il tipo di archiviazione o il nome, ma anche le colonne e le chiavi. La sintassi del comando è la seguente:
ALTER [IGNORE] TABLE tbl_name
alter_specification [, alter_specification] ...
alter_specification:
ADD [COLUMN] column_definition [FIRST | AFTER col_name ]
| ADD [COLUMN] (column_definition,...)
| ADD INDEX [index_name] (index_col_name,...)
| ADD PRIMARY KEY (index_col_name,...)
| ADD UNIQUE [index_name] (index_col_name,...)
| ADD [index_name] (index_col_name,...)
| ALTER [COLUMN] col_name {SET DEFAULT literal | DROP DEFAULT}
| CHANGE [COLUMN] old_col_name column_definition
[FIRST|AFTER col_name]
| DROP [COLUMN] col_name
| DROP PRIMARY KEY
| DROP INDEX index_name
| RENAME [TO] new_tbl_name
| ORDER BY col_name
(La sintassi riportata non è quella integrale. Gli interessati alla sintassi completa troveranno il link nell'ultimo paragrafo dell'articolo)
Qui di seguito saranno trattate le varie possibilità offerte da ALTER TABLE raggruppando le sintassi. Se si devono eseguire modifiche multiple della tabella non è necessario lanciare comandi separati: basta dividerli con una virgola.
Aggiunta di una o più colonne
ADD [COLUMN] column_definition [FIRST | AFTER col_name ]
ADD [COLUMN] (column_definition,...) 
Queste sintassi permettono di aggiungere una colonna, e di specificarne la posizione all'interno della tabella, o di aggiungere più colonne senza specificarne la posizione. Il campo column_definition deve contenere la definizione della colonna, ed è la stessa sintassi usata nel comando CREATE TABLE.
Aggiunta di un indice
ADD [INDEX] [index_name] (index_col_name,...)
ADD PRIMARY KEY (index_col_name,...)
ADD UNIQUE [index_name] (index_col_name,...) 
Usando questa tipologia di comandi è possibile aggiungere degli indici alla tabella specificando l'elenco di campi ad esso associati. Si possono creare tutti i tipi di indici supportati da MySql, ovvero PRIMARY KEY, UNIQUE e INDEX.
Modifica di una colonna
ALTER [COLUMN] col_name {SET DEFAULT literal | DROP DEFAULT}
CHANGE [COLUMN] old_col_name column_definition
[FIRST|AFTER col_name] 
ALTER e CHANGE permettono di modificare le propietà di una colonna. Il primo consente di modificare o eliminare il valore di default, mentre il secondo consente di cambiare tutte le propietà compreso il valore di default.
Eliminazione di indici e colonne
DROP [COLUMN] col_name
DROP PRIMARY KEY
DROP INDEX index_name 
I comandi sopra riportati permettono, rispettivamente, l'eliminazione di: 
Colonne 
Chiavi primarie 
Indici (sia unici che normali)
Per eliminare la PRIMARY KEY è presente un comando apposito essendo questa unica nella tabella, mentre il comando DROP INDEX va usato per eliminare tutti gli altri tipi di indici.
Rinominare la tabella 
RENAME [TO] new_tbl_name 
La sintassi RENAME cambia il nome alla tabella.
Ordinare la tabella
ORDER BY col_name 
Questo comando permette di cambiare l'ordinamento di default di una tabella in base alla colonna specificata in col_name.
Controllare e Riparare una tabella
A volte può succedere che una tabella si danneggi a seguito di un errore o di un'improvvisa interruzione del servizio. MySql, come anche altri database, mette a disposizione una serie di comandi per verificare la struttura delle tabelle ed eventualmente ripararle. Questi comandi sono estremamente semplici, infatti richiedono solo il nome della tabella e l'accuratezza del controllo o della riparazione.
CHECK TABLE tbl_name {QUICK | FAST | CHANGED | MEDIUM | EXTENDED} 
Le modalità di verifica sono le seguenti: 
QUICK, esegue un controllo estremamente veloce, non controlla la correttezza delle struttura dei record 
FAST, verifica solamente se la tabella è stata chiusa correttamente 
CHANGED, modalità più accurata della FAST 
MEDIUM, controlla il contenuto della tabella, ma non in maniera accurata 
EXTENDED, controlla il contenuto della tabella, la struttura, gli indici e quant'altro è possibile controllare
È importante eseguire un controllo di tipo EXTENDED poiché il risultato è accurato al 100%, anche se questo può richiedere svariato tempo.
Nel caso che CHECK TABLE riporti una tabella come danneggiata è sufficente eseguire il comando REPAIR TABLE per riparare la tabella.
REPAIR TABLE tbl_name [, tbl_name] ... [QUICK] [EXTENDED] 
Esistono due modalità di riparazione e sono: 
QUICK, vengono ricostruiti solamente gli indici 
EXTENDED, il comando ricostruisce la tabella riga per riga
La seconda modalità è necessaria solo in casi critici: l'operazione di riparazione, se la tabella è grande, potrebbe impiegare molto tempo.
Ottimizzare le tabelle
MySql, tra le svariate funzionalità che mette a disposizione, permette anche di ottimizzare le tabelle. L'ottimizzazione delle tabelle consiste nell'eliminazione dello spazio vuoto che si viene a creare tra i record dopo operazioni di modifica ed eliminazione.
OPTIMIZE TABLE tbl_name [, tbl_name] ... 
Il parametro tbl_name contiene semplicemente il nome della tabella. È possibile definire più tabelle separando i nomi tramite delle virgole.
Comunque non è sempre necessario eseguire l'ottimizzazione su tutte le tabelle, infatti in automatico le righe eliminate, e quindi lo spazio vuoto, viene riusato scrivendo i nuovi record inseriti nella tabella. È però importanto farlo quando vengono eliminate grosse quantità di dati o viene sensibilmente alterata la struttura della tabella.
Backup e Ripristini
È possibile anche eseguire dei backup integrali tramite comandi sql. Non è un metodo molto consigliato ma risulta estremamente utile in situazioni particolari.
BACKUP TABLE tbl_name [, tbl_name] ... TO '/path/to/backup/directory'
È possibile definire più tabelle da salvare ed è necessario specificare il percorso nel quale queste verrano salvate. Se si volesserò salvare più tabelle contemporaneamente, è conveniente usare il comando LOCK per bloccare tutte le tabelle interessate in modo da evitare che durante il backup su alcune venga scritto e si perdano dei riferimenti. 
Attenzione: questo comando scrive direttamente su disco ed è quindi necessario avere il permesso file e aver impostato i permessi corretti alla cartella di destinazione, altrimenti si potrebberò verificare degli errori!
Ripristinare è altrettanto semplice: 
RESTORE TABLE tbl_name [, tbl_name] ... FROM '/path/to/backup/directory' 
La sintassi è identica a BACKUP TABLE. L'operazione di ripristino, a differenza di quella di backup, che si limita a copiare i file delle tabelle, ricostruisce anche gli indici, quindi su database di grandi dimensioni potrebbe impiegare molto tempo.
Per chi volesse avere informazioni più dettagliate sull'argomento si rimanda al manuale ufficiale di MySql (http://dev.mysql.com/doc/mysql/en/)

Stringhe in MySQL: trucchi e soluzioni
(http://freephp.html.it/articoli/view_articolo.asp?id=167)
Il tipo di campo più importante dal punto di vista dell’utente in materia di database è rappresentato dalle stringhe, utili per immagazzinare descrizioni comprensibili. MySQL, come ogni altro database server, è in grado di gestire molteplici campi di testo ed applicarvi un gran numero di funzioni integrate: in questo articolo vedremo come gestire questa potenzialità.
I campi di tipo testuale
MySQL supporta principalmente due tipi di campi testuali a cui ne vanno aggiunti altri che presentano alcune particolarità.
CHAR e VARCHAR
Il CHAR è un campo a dimensione fissa, vengono utilizzati tanti bytes quanti sono i caratteri massimi per i quali è stato impostato il campo: se il campo viene impostato a CHAR(5), con la possibilità cioè di salvare 5 caratteri, le stringhe 'abaco' e 'ape' occuperanno lo stesso spazio nel database.
Il VARCHAR in maniera opposta utilizza per la memorizzazione un numero di bytes pari al numero di caratteri salvati più un byte per la dimensione della stringa. I campi VARCHAR, pur presentando il vantaggio di occupare un minor spazio in termini di bytes, impediscono alla tabella di diventare “fixed” e ne rallentano quindi l'utilizzo. Una tabella può essere impostata come “fixed” solo se tutti i campi sono di tipo numerico o CHAR.
È possibile immagazzinare fino a 255 caratteri ed è necessario specificare la dimensione del campo al momento della creazione dello stesso; se il dato immesso superasse la dimensione prefissata verrebbe troncato. Esempio: La stringa 'Alberto' inserita in un campo CHAR(5) verrà immagazzinata come 'Alber'.
I due tipi di campo differiscono anche per l'applicazione della funzione trim, ovvero l'eliminazione di caratteri di spaziatura ad inizio o fine di riga: VARCHAR elimina gli spazi in fase di inserimento dei dati, CHAR nel momento in cui vengono richiamati.
Tipo del campo | CHAR(9) | VARCHAR(9) | CHAR(9) | VARCHAR(9) |
Dato inserito | 'Cane ' | 'Cane ' | 'Astronave ' | 'Astronave ' |
Bytes usati | 9 | 5 | 9 | 10 |
Dato memorizzato | 'Cane ' | 'Cane' | 'Astronave' | 'Astronave' |
Dato restituito | 'Cane' | 'Cane' | 'Astronave' | 'Astronave' |
TEXT (TINYTEXT, TEXT, MEDIUMTEXT, LONGTEXT)
Questo tipo di campo è molto simile al VARCHAR ma se ne differenzia per il numero di caratteri che è possibile memorizzare. Ha quattro differenti "sottotipi":
TINYTEXT fino a 2^8 caratteri (256 bytes) 
EXT fino a 2^16 caratteri (oltre 65000, 64 Kbytes) 
MEDIUMTEXT fino a 2^24 caratteri (oltre 16 milioni di bytes, 16 Mbytes) 
LONGTEXT fino a 2^32 caratteri (oltre 4 miliardi di bytes, 4 Gbytes)
Generalmente impostando un campo come TEXT non dovreste avere alcun tipo di problema a meno che non abbiate necessità di inserire enormi moli di dati. C'è da considerare inoltre che questi limiti teorici vanno ridimensionati nell'uso reale a causa del passaggio di dati tra client e server (ad esempio tra uno script php e il database) che è a sua volta limitato dall'opzione max_allowed_packet impostato generalmente ad un Mbyte e del limite fisico della dimensione dei file che dipende dal sistema operativo (è da ricordare infatti che una tabella di mysql è salvata nel filesystem come un file qualsiasi).
BLOB
Questo è il classico campo per la memorizzazione di dati binari e viene utilizzato per memorizzare nel database immagini, documenti, eseguibili e file in genere. Per approfondire l'argomento potete leggere l'articolo di Giancarlo Moschitta "Files dentro a MySQL". Anche in questo caso sono presenti quattro "sottotipi" (TINYBLOB, BLOB, MEDIUMBLOB, LONGBLOB) e la limitazione sulla dimensione è la stessa degli equivalenti campi di tipo TEXT.
ENUM/SET
Altri due campi che possono contenere stringhe sono ENUM e SET che vengono utilizzati nei casi in cui la stringa inserita debba fare parte di un ristretto cerchio di opzioni specificate in fase di creazione del campo. Il vantaggio di questi tipi di campo è dato dal fatto che per ogni record inserito verrà utilizzato solo un byte (o due se si superano i 256 elementi) per memorizzare la chiave numerica corrispondente al valore desiderato.
ENUM consente di specificare oltre 65000 elementi (2^16) e viene utilizzato per opzioni prefissate. Ad esempio si può impostare un campo ENUM con tre elementi ('Mucca', 'Pecora', 'Cavallo'), a questo punto per quel campo ad ogni record non verrà salvata l'intera stringa, ma solamente un numero corrispondente alla stessa; nel nostro caso NULL per NULL, 0 per una stringa vuota (""), 1 per 'Mucca', 2 per 'Pecora' e 3 per 'Cavallo'.
SET è utilizzato invece in quei casi in cui i valori si possono presentare contemporaneamente (l'esempio classico è dato dai permessi su un file). A causa della modalità in cui vengono salvati i valori inseriti, essi non possono contenere virgole. Il campo può contenere fino ad un massimo di 64 specificazioni.
Considerazioni sui campi di testo
Case sensitive o unsensitive?
I campi stringa di MySQL sono gestiti in maniera case unsensitive dalla versione 3.23, questo significa che da quella versione le stringhe 'Milano' e 'MILANO' vengono considerate uguali anche se vengono salvate nelle rispettive forme originarie. Per far sì che vengano considerate le differenze tra le due forme è necessario usare la parola chiave BINARY in fase di query.
Esempio: Regione, capoluogo = 'Lombardia', 'Milano'
SELECT regione FROM regioni WHERE BINARY capoluogo = 'Milano'; // una corrispondenza
SELECT regione FROM regioni WHERE BINARY capoluogo = 'MILANO'; // nessuna corrispondenza
La codifica di memorizzazione
Dalla versione 4.1 MySQL permette di specificare la codifica da utilizzare per una specifica tabella e addirittura per ogni singola colonna; questo può essere molto utile nel caso in cui si lavori in un sistema multilingua. Per maggiori informazioni su questa caratteristica, che comunque nella maggior parte dei casi non comporta alcun cambiamento, si rimanda al manuale ufficiale.

Le funzioni stringa
Molte delle funzioni che agiscono sulle stringhe che utilizziamo in php sono disponibili già a livello di query per MySQL. I vantaggi nell'utilizzo delle funzioni a livello di query sono l'estrema velocità dell'elaborazione fornita da MySQL e il fatto che il motore è in grado di decidere da solo a quali record è necessario applicare una funzione e per quali questo è superfluo, ad esempio non verrà applicata una funzione per rendere la stringa minuscola se questa è già minuscola, e quindi la funzione viene eseguita soltanto dove veramente necessario.
Oltre a questo va considerato il caching fornito dalle versioni 4.0 di MySQL che permette di avere un veloce accesso ai dati già prelevati da una precedente query. Per contro le query saranno difficilmente portabili su altre piattaforme, per cui le applicazioni dovranno essere progettate unicamente per girare su MySQL.
Facciamo velocemente una carrellata delle principali funzioni che possono tornare utili raggruppandole per categoria.
Ricerca e sostituzione
INSTR(pagliaio, ago)
Equivalente in php: strpos($pagliaio, $ago)+1
Questa funzione dà come risultato la posizione della sottostringa ago nella stringa pagliaio. Da notare che il valore varia da 1 alla lunghezza della stringa e che 0 viene restituito quando non c'è corrispondenza. In pratica restituisce sempre un'unità in meno di quello che restituirebbe la funzione analoga in php.
SELECT INSTR('Ballatoio', 'io') FROM tabella; // 8
LOCATE(ago, pagliaio[, inizio])
Equivalente in php: strpos($pagliaio, $ago[, $inizio])+1
Questa funzione dà come risultato la posizione della sottostringa ago nella stringa pagliaio partendo dal carattere inizio. Da notare che l'ordine della stringa in cui cercare e della sottostringa da cercare sono invertiti rispetto alla funzione in php e alla funzione INSTR e che inoltre il valore varia da 1 alla lunghezza della stringa. 0 viene restituito quando non c'è corrispondenza. In pratica restituisce sempre un'unità in meno di quello che restituirebbe la funzione analoga in php.
SELECT LOCATE('io', 'Ballatoio') FROM tabella; // 8
REPLACE(stringa, cosa, concosa)
Equivalente in php: str_replace($cosa, $concosa, $stringa)
Questa funzione restituisce la stringa passata come primo argomento a cui sono state sostituite tutte le occorrenze di cosa con concosa.
Attenzione all'ordine diverso dei parametri rispetto alla funzione in php.
SELECT REPLACE('Ballatoio', 'io', 'ao') FROM tabella; // Ballatoio
INSERT(stringa, inizio, lunghezza, sostituto)
Equivalente in php: substr_replace($stringa, $sostituto, $inizio[, $lunghezza])
Questa funzione restituisce la stringa passata come primo parametro dove i caratteri da inizio e lunghezza sono stati sostituiti con la stringa sostituto. Attenzione all'ordine diverso dei parametri rispetto alla funzione php e alla necessità di specificare tutti e quattro i parametri.
SELECT INSERT('Ballatoio', 8, 2, 'ao') FROM tabella; // Ballatoao
Sottostringhe
LEFT(stringa, lunghezza)
Equivalente in php: substr($stringa, 0, $lunghezza)
Questa funzione restituisce una sottostringa composta dai primi lunghezza caratteri di stringa. 
SELECT LEFT('Ballatoio', 2) FROM tabella; // Ba
RIGHT(stringa, lunghezza)
Equivalente in php: substr($stringa, -$lunghezza)
Questa funzione restituisce gli ultimi lunghezza caratteri di stringa.
SELECT RIGHT('Ballatoio', 2) FROM tabella; // io
SUBSTRING(stringa, inizio, lunghezza)
Equivalente in php: substr($stringa, $inizio, $lunghezza)
Questa funzione restituisce una sottostringa di lunghezza caratteri a cominciare dal carattere in posizione inizio.
SELECT SUBSTRING('Ballatoio', 2, 4) FROM tabella; // llat
SUBSTRING_INDEX(stringa, pattern, inizio)
Equivalente in php: substr($stringa, strpos($stringa, $pattern, $inizio))
Questa funzione restituisce una sottostringa di stringa a cominciare dalla prima occorrenza di pattern.
SELECT RIGHT('Ballatoio', 'a', 0) FROM tabella; // llatoio
Modifica di stringa
LOWER(stringa)
Equivalente in php: strtolower($stringa)
Questa funzione restituisce stringa con tutti i caratteri maiuscoli trasformati in minuscoli.
SELECT LOWER('BaLLatoio') FROM tabella; // ballatoio
UPPER(stringa)
Equivalente in php: strtoupper($stringa)
Questa funzione restituisce stringa con tutti i caratteri minuscoli trasformati in maiscoli.
SELECT UPPER('BaLLatoio') FROM tabella; // BALLATOIO
LTRIM(stringa)
Equivalente in php: ltrim($stringa)
Questa funzione restituisce stringa eliminando gli spazi a sinistra.
SELECT LTRIM(' Ballatoio ') FROM tabella; // “Ballatoio “
RTRIM(stringa)
Equivalente in php: rtrim($stringa)
Questa funzione restituisce stringa eliminando gli spazi a destra.
SELECT RTRIM(' Ballatoio ') FROM tabella; // “ Ballatoio”
TRIM([(BOTH|LEADING|TRAILING) [carattere] FROM] stringa)
Equivalente in php: trim($stringa[, carattere])
Questa funzione restituisce stringa eliminando carattere dalla stessa a sinistra se è specificato LEADING, a destra se è specificato TRAILING e da entrambe le parti se è specificato BOTH o niente.
Se carattere non è passato viene considerato lo spazio come elemento da eliminare.
Attenzione alla notazione particolare di questa funzione.
SELECT TRIM('o' FROM 'Ballatoio') FROM tabella; // Ballati
Altre
CHAR_LENGHT(stringa)
Equivalente in php: strlen($stringa)
Questa funzione restituisce il numero di caratteri di cui è composta stringa. Da notare bene il funzionamento diverso della funzione LENGHT che restituisce la dimensione in bytes e non i caratteri, falsando i risultati nel caso in cui si utilizzino caratteri multibytes.
SELECT CHAR_LENGHT('Ballatoio') FROM tabella; // 9
CONCAT(stringa1, stringa2, stringa3, ...)
Equivalente in php: $stringa1 . $stringa2 . $stringa3
Questa funzione permette di concatenare due o più stringhe.
SELECT CONCAT('Bal', 'la', 'to', 'io') FROM tabella; // Ballatoio
CONCAT_WS(colla, stringa1, stringa2, stringa3)
Equivalente in php: implode($colla, array($stringa1, $stringa2, $stringa3))
Questa funzione permette di creare un'unica stringa composta dalle stringhe passate dal secondo parametro in poi separandole da un divisore indicato dal primo parametro.
SELECT CONCAT_WS('.', 'Bal', 'la', 'to', 'io') FROM tabella; // Bal.la.to.io

Autenticare gli utenti con PHP
http://www.webmasterpoint.org/php/tutorial/92_2.asp
Quello dell’autenticazione degli utenti è da sempre un problema molto sentito da parte di tutti i webmaster. Inibire l’accesso a determinate aree del proprio sito può essere necessario per molteplici motivi. I siti che offrono servizi a pagamento, ad esempio, devono disporre di zone accessibili soltanto agli utenti registrati. Chi crea delle aree di amministrazione per il proprio sito (cosa molto comune, in PHP) avverte chiaramente l’esigenza di proteggere le pagine con cui gestisce tutto il sito.
Per questi e per tanti altri motivi gli sviluppatori web si adoperano da sempre creando script o sfruttando le caratteristiche dei vari web server (Apache in primis) per proteggere files e cartelle dei propri siti. Anche il PHP interagisce al meglio con i web server (creando ad esempio dei file .htaccess di Apache) e, cosa di cui tratteremo in queste pagine, può inviare degli header HTTP al browser che richiedano nome e password dell’utente. Sfrutteremo questa caratteristica del PHP per richiedere i dati dell’utente, che cercheremo poi in un database. Se l’utente esiste permetteremo l’accesso, altrimenti ne consentiremo l’iscrizione inserendo i nuovi dati nel DB stesso. Per provare l’esempio di queste pagine ci sarà bisogno di un webserver Apache, del PHP e di MySQL. Troverete tutti i software necessari nella sezione “Il meglio” del CD-Rom di questo mese.
La tabella utenti
Visto che conserveremo in un database i dati degli utenti, la prima cosa da fare è di sicuro quella di creare il DB stesso e la tabella che conterrà tali dati. La struttura della tabella sarà molto semplice, formata da soli sei campi:
Id – il campo che fungerà da contatore
Nome – lo username scelto dall’utente in fase di registrazione
Email – la sua e-mail, che servirà anche per inviare la password
Password – il campo che conterrà la password
Data – la data di registrazione
Ip – l’indirizzo IP dell’utente al momento della registrazione
Dopo aver avviato il server MySQL (si può fare riferimento all’altro articolo di pratica presente in questo numero) apriamo una sessione di DOS e, dalla sottocartella bin di MySQL, lanciamo il client digitando mysql.
Il codice SQL da digitare per creare la nostra tabella (che chiameremo anagrafica) è il seguente:
CREATE database utenti;
USE utenti;
CREATE TABLE anagrafica (
id int(3) NOT NULL auto_increment,
nome char(8) NOT NULL default '',
email char(255) NOT NULL default '',
password char(8) NOT NULL default '',
data char(255) NOT NULL default '',
ip char(15) NOT NULL default '',
PRIMARY KEY (id),
UNIQUE KEY id (id),
KEY id_2 (id) ) TYPE=MyISAM;
è possibile copiare il codice esattamente come lo si vede; battere il tasto invio alla fine di ogni riga, non dimenticando di digitare il punto e virgola alla fine, per dire a mysql che l’istruzione stessa è terminata. I nomi da attribuire al DB e alla tabella possono essere cambiati a seconda delle prorie esigenze; l’importante è specificarli nel file di configurazione che creeremo tra poco.
Si comincia col PHP
Ora che abbiamo la tabella nella quale memorizzare i dati, possiamo iniziare a scrivere un po’ di codice PHP. Stabiliamo, per essere ordinati, che creeremo tre piccoli script PHP, in tre diversi file.
Il primo conterrà semplicemente i dati di connessione al database, mentre il secondo invierà gli header, ed il terzo permetterà di iscriversi agli utenti che ancora non compaiono nella tabella. La struttra dei tre file è molto semplice; vediamo dapprima di scrivere il codice del file di configurazione da includere negli altri due, e che chiameremo conf.inc.php:
<?
$data = date ("d/m/Y H:i");
con l’istruzione date ricaveremo facilmente la data nel formato GG/MM/AAAA (giorno, mese, anno). Scriviamo ora i fondamentali dati per connettersi correttamente al server MySQL:
$server = "localhost";
$utente = "root";
$db_pass = "";
$datab = "gol61";
$tabella = "anagrafica";
oltre all’indirizzo dell’host e i dati dell’utente, abbiamo conservato in due variabili quelli con il nome del database da utilizzare e quello della tabella. Volendo personalizzare questi dati sarà sufficiente intervenire sulle due variabili. Com’è ormai nostra abitudine, creeremo una piccola funzione al’interno di questo file, chiamata errore_server(). Questa funzione servirà semplicemente ad informarci minuziosamente su eventuali errori in fase di connessione e di interrogazione.
function errore_server()
{
echo "<b>Il database MySql sembra
non rispondere...</b><br>MySql
dice:<br><font color=red>";
echo mysql_error();
echo "</font><br>pregasi
<a href=\"mailto:iltuo@indirizzo.com\">
segnalare</a> il problema";
}
A questo punto non dobbiamo fare altro che connetterci al server e selezionare, direttamente in questa fase, il database da utilizzare.
$connessione = @mysql_connect ($server, $utente, $db_pass)
or die (errore_server ());
$db = mysql_select_db ($datab, $connessione)
or die (errore_server ());
?>
Salviamo il file conf.inc.php in una cartella del nostro webserver, e pensiamo a creare quello che sarà l’indice della cartella stessa.
Sei autorizzato? Controlliamo…
Il file index.php avrà l’importantissimo compito di inviare gli headers e, una volta che l’utente abbia inserito i dati richiesti, di verificare che questi siano presenti nel database.
Per fare una prova, e visualizzare tutti gli headers di una richiesta http, possiamo prendere in prestito un’esempio direttamente dal manuale PHP:
<?
$headers = getallheaders();
while (list ($header, $value) = each ($headers)) {
echo "$header: $value<br />\n";
}
echo $REMOTE_ADDR;
?>
Questo piccolo ciclo while approfitta dell’istruzione getallheaders() per restituire i valori dell’array definito dall’istruzione stessa. Gli headers sono in realtà di molteplici tipi, e quello che ci interessa si chiama $PHP_AUTH_USER. Ricordiamo che gli headers vanno inviati al browser prima di qualsiasi altra cosa, anche di un solo semplice carattere, onde evitare spiacevoli errori. Ecco quindi le prime righe del nostro file index.php
<?
if (!isset($PHP_AUTH_USER)) {
header('WWW-Authenticate: Basic realm="Area privata"');
header('HTTP/1.0 401 Unauthorized');
echo 'Richiesta autorizzazione.';
exit; }
Queste poche istruzioni controllano che il valore $PHP_AUTH_USER non sia presente nell’ambiente (if (!isset…) e lanciano la classica finestrella di autenticazione http, dove si dovranno inserire lo username e la password. In caso di errore ci si limiterà a stampare a video la frase Richiesta autorizzazione. Qualora l’utente abbia inserito i dati richiesti, ricorreremo ad un else che ne controllerà l’esistenza nel DB.
else {
include ("conf.inc.php");
ovviamente includeremo all’inizio di questo ciclo il file che contiene le configurazioni. Subito dopo penseremo a creare la query e ad eseguirla sul database:
$sql = "SELECT id FROM $tabella WHERE nome='$PHP_AUTH_USER'
and password='$PHP_AUTH_PW'";
$query = mysql_query($sql) or die (errore_server());
la query può fornire un solo risultato o riga (il nome utente deve infatti essere necessariamente univoco). Controlliamo quindi il suo valore, grazie all’istruzione mysql_num_rows
$num = mysql_numrows($query);
if ($num == 1) {
echo "<P>Ok, sei autorizzato<br>";
echo "Il tuo nome utente è <b>$PHP_AUTH_USER</b><br>";
echo "La tua passwd è <b>$PHP_AUTH_PW</b></p>";
}
Se il risultato è uguale ad 1 il nome utente esiste, e corrisponde alla password digitata. Nell’esempio abbiamo semplicemente mostrato a video i dati digitati, ma è proprio qui (all’interno del bracket) che potrete inserire il codice riservato agli utenti presenti nel DB. È anche plausibile pensare di includere un file invece di scrivere tutto il codice che serve; si dia un’occhiata al boxino di queste pagine per approfondire.
else if ($num == 0)
{
echo "Nome utente o password non validi<br>";
echo "<a href=\"iscriviti.php\">iscriviti</a>";
}}
Se invece il risultato della query è uguale a zero visualizzeremo un link che rimanda al file per iscriversi nel database.
L’iscrizione degli utenti
Memorizzare gli utenti nel database è meno difficile di quello che sembra.
Il file iscriviti.php non dovrà far altro che visualizzare un form HTML e, dopo aver controllato che lo username inserito non sia già presente, inserire i dati nella tabella stessa. Dopo avere svolto questo compito, invieremo due distinte e-mail: una a chi si è appena iscritto, e un’altra al proprietario del sito stesso, per informarlo della presenza di un nuovo utente. Creeremo un ciclo if che controlli inizialmente la presenza della variabile $invia (il nome del pulsante del form HTML). Se questa non esiste, si visualizza subito il form:
<?
include ("conf.inc.php");
if (!$invia){
echo <<
Il tuo nome utente non è stato trovato nel database
<br>Registrati<br> </h1>
<form method=post>
<table width=85% border=1 align=center> <tr><td>Nome</td>
<td> <input type="text" name="nome"> </td></tr>
<tr> <td>Email</td>
<td><input type="text" name="email"></td> </tr> <tr>
<td>passwd</td>
<td><input type="password" name="passwd"></td>
</tr>
<tr>
<td align=right><input type="submit" name="invia"></td>
<td align=left><input type="reset"></td>
</tr>
</table>
</form>
EOD;
}
Da notare che, usando questa “tecnica”, non abbiamo neanche bisogno di specificare l’action del form stesso. Se il pulsante viene premuto potremo proseguire con i controlli del caso e l’eventuale inserimento; vediamo prima se il nome utente esiste:
else {
$sql = "select * from $tabella where nome='$nome'";
$query =mysql_query ($sql) or die (errore_server());
$num = mysql_numrows($query);
if ($num == 1) {
echo "nome utente già occupato<br>";
echo "<a href=\"javascript:history.back()\">ritenta</a>
con un altro username";
}
Utilizzando la solita istruzione mysql_numrows controlleremo il risultato della query e, qualora esso sia maggiore di 0, rimanderemo indietro l’utente per farlo riprovare con un altro nick.
else {
$ip = $REMOTE_ADDR;
$sql="INSERT INTO anagrafica (id,nome,email,password,
data,ip) VALUES ('', '$nome', '$email',
'$passwd', '$data', '$ip')";
$query = mysql_query ($sql) or die (errore_server());
echo "dati inseriti correttamente<br>";
E Inviamo le e-mail
Dopo aver inserito tutti i dati dell’utente nel nostro bravo database, possiamo pensare a inviare le due e-mail. La prima, come dicevamo, sarà indirizzata all’utente e conterrà i suoi dati, a mò di promemoria, e l’altra arriverà al webmaster del sito. Vediamo il codice della prima mail:
$from_mail = "iltuo@indirizzo.tld";
$To="$email";
$Headers ="From: $from_mail";
$Soggetto="[Inserire nome del sito] I tuoi dati di accesso";
$Corpo.="Ciao!\n\n";
$Corpo.="Sono il programma Sendmail di http://$HTTP_HOST\n";
$Corpo.=" La tua iscrizione è stata accettata!\n\n";
$Corpo.=" Questi sono i tuoi dati:\n\n";
$Corpo.=" Il tuo nome utente: $nome\n";
$Corpo.=" La tua password: $passwd\n\n";
$Corpo.=" A presto!\n\n";
$Corpo.="--------------------------------------------\n";
$Corpo.="$from_mail\n";
$Corpo.="http://$HTTP_HOST\n";
$Corpo.="--------------------------------------------\n";
La variabile $from_mail conterrà l’indirizzo che verrà visualizzato come mittente dell’e-mail, e che inseriremo negli headers della mail (occhio, non sono quelli uguali http…:) ). In $To lo script prenderà l’indirizzo dell’utente per utilizzarlo come destinatario, mentre in $Soggetto il testo (personalizzabile) dell’oggetto della mail. Per quanto riguarda il contenuto del messaggio, esso verrà creato concatenando la variabile $Corpo, in modo da inviare un messaggio composto da più righe ordinate. Abbiamo inserito nel corpo anche la variabile d’ambiente $HTTP_HOST, giusto per includere nel messaggio anche il nome del sito.
mail($To, $Soggetto, $Corpo, $Headers);
echo "ti è stata inviata una mail all'indirizzo
$email con i tuoi dati";
Praticamente la stessa cosa sarà da farsi con l’e-mail da inviare al webmaster del sito.
$webmaster = "iltuo@indirizzo.tld";
$email1 ="$email";
$mailTo1="$webmaster";
$mailHeaders1="From: $email1";
$mailSubject1="[Inserire il nome del sito]
Nuovo UTENTE registrato";
$mailBody1.="Ciao!\n\n";
$mailBody1.="Un nuovo utente si è registrato!\n\n";
$mailBody1.="Questi sono i suoi dati:\n\n";
$mailBody1.="Username: $nome\n";
$mailBody1.="passwd: $passwd\n";
$mailBody1.="Email: $email1\n";
mail($mailTo1, $mailSubject1, $mailBody1, $mailHeaders1);
}}
Abbiamo approfittato per chiudere i cicli ancora aperti; il compito dello script, in realtà, è terminato.

AlberT-menu è una semplice funzione PHP che stampa una tabella di menù
Preparando un vettore contente link, testo e alt è possibile generare facilmente un menù graficamente coerente senza mettere mano al codice HTML.
Ecco ad esempio uno stralcio da SuperAlberT (la tabella dei "Links Utili"):
<?php
$alt="Links da non perdere";
$link['testo'][0] = "WebConf";
$link['href'][0] = "http://www.SuperAlberT.it/webconf";
$link['testo'][1] = "GaliLINUX";
$link['href'][1] = "http://galileo.roma2.infn.it";
$link['testo'][2] = "ZioBudda.net";
$link['href'][2] = "http://www.ziobudda.net";
print_table_menu($config["imagedir"]."/links.gif","",$alt,$link);
?>

In PHP esiste una funzione tipo lastModified di javascript?
No, ma la puoi simulare in questo modo:
echo date(\"F d y H:i:s\", getlastmod());

Come posso sapere l‘indirizzo IP di chi stà visitando una pagina PHP?
La funzione getenv() del Php permette di reperire le variabili d‘ambiente del server; in questo modo è semplice reperire l‘indirizzo IP di un visitatore.
Il codice seguente stampa a video l‘Ip del nostro visitatore:
Il tuo indirizzo IP è <?echo getenv("REMOTE_ADDR")?>

E' possibile validare i campi di un form attraverso PHP?
Ammettendo che tu debba controllare la compilazione di un campo chiamato "nome" proveniente da un form HTML, potresti usare una piccola struttura IF
<?
if ($nome==""){
echo "Scrivi il tuo nome!";
}
else{
echo "Ciao $nome!";
}
?>

Generatore di password casuali
Nello sviluppo di applicazioni di autenticazione si può incontrare la necessità di dover generare valori casuali da utilizzare come password.
In questo articlùolo vedremo appunto come fare ciò utilizzando le funziuoni chr() e rand() offerte dal PHP.
Nello specifico poniamo di avere la necessità di creare delle password casuali di 10 caratteri composte sia da numeri che da lettere.
Ecco il codice:
<?
// Imposto la lunghezza della password a 10 caratteri
$lung_pass = 10;
// Creo un ciclo for che si ripete per il valore di $lung_pass
for ($x=1; $x<=$lung_pass; $x++)
{
// Se $x è multiplo di 2...
if ($x % 2){
// Aggiungo una lettera casuale usando chr() in combinazione
// con rand() che genera un valore numerico compreso tra 97
// e 122, numeri che corrispondono alle lettere dell'alfabeto
// nella tabella dei caratteri ASCII
$mypass = $mypass . chr(rand(97,122));
// Se $x non è multiplo di 2...
}else{
// Aggiungo alla password un numero compreso tra 0 e 9
$mypass = $mypass . rand(0,9);
}
}
// Stampo a video il risultato
echo $mypass;
?>
Come unica nota vorrei soffermarmi un istante sulla funzione chr() la quale serve per recuperare un carattere ASCII attraverso l'indicazione del suo numero di corrispondenza all'interno della tabella dei caratteri ascii (vedi sito Asciitable.com).
Nel nostro caso abbiamo utilizzato chr() insieme a rand() per generare, appunto, un numero compreso tra 97 e 122, numeri che corrispondono alle lettere del nostro alfabeto.

Le Sessioni
Un altro sistema di memorizzazione di informazioni è l'utilizzo delle sessioni.
A differenza dei cookie le sesioni non scrivono nulla sul computer del utente, ma operano (quasi esclusivamente) sul nostro server creando degli specifici files dove vengono salvati alcuni dati importanti relativamente alla sessione di navigazione del nostro utente. Una volta che la sessione sarà terminata il files con i dati della sessione verrà eliminato. Una sessione termina nel momento in cui l'utente chiude il browser.
Le sessioni vengono utilizzate ad esempio nella gestione delle autenticazioni (login) degli utenti che, una volta loggati, verranno identificati come tali da tutte le pagine (.php) del sito.
La prima cosa da fare se vogliamo lavorare con le sessioni è impostare nel file di configurazione del PHP (&quotphp.ini") la direttiva session.save_path, indicando la directory nella quale verranno salvate le informazioni sulle sessioni dei nostri utenti.
La funzione da utilizzare poi all'interno delle nostre pagine .php per aprire una sessione è session_start(). Questa funzione non prevede parametri.
La funzione session_start() deve essere necessariamente utilizzata prima dell'invio di codice html: nella parte precedente del nostro files .php non deve pertanto essere già stato scritto ed inviato del codice html il quale comprometterebbe il buon esito della nostra funzione.
Facciamo un esempio per vedere in concreto come funziona session_start().
Poniamo di voler aprire una sessione dove salvare username e password del nostro utente (dati che ci sono stati forniti tramite un form di login). Ecco il codice:
<?
//Recupero username e password dal form
$username = $_POST['user'];
$password = $_POST['pass'];
//Apro la sessione e...
session_start();
//Salvo i dati...
$_SESSION['username'] = $username;
$_SESSION['password'] = $password;
?>
A questo punto abiamo salvato all'interno della nostra sessione (grazie a $_SESSION) due diverse variabili: username e password.
Nelle successive pagine .php sarà molto semplice recuperare questi valori, ecco un esempio:
<?
//Apro la sessione e...
session_start();
//Recupero i dati...
$username = $_SESSION['username'];
$password = $_SESSION['password'];
//facciamo una stampata a video!
echo "Ciao " . $username . " la tua password è " . $password;
?>
Per finire vediamo come eliminare una sessione (ad esempio a seguito di logout).
//Per eliminare una specifica variabile di sessione useremo:
unset($_SESSION['username']);
//Per eliminare tutte le variabili di sessione useremo:
$_SESSION = array();

Gestire i Cookie
I Cookie sono un metodo rapido per memorizzare, sul computer dei nostri utenti, delle informazioni che vogliamo persistano anche nelle successive visite al nostro sito.
I Cookie sono molto utili per memorizzare piccoli dati come ad esempio il nome dell'utente o una serie di preferenze. I cookie non sono adatti per informazioni critiche come password o dati personali in quanto potrebbero crearsi dei problemi di sicurezza.
Per impostare un cookie useremo setcookie() in questo:
setcookie("nome_utente", "pippo", time()+3600);
Come vedete all'interno del comando setcookie() abbiamo inserito 3 parametri:
- il primo specifica il nome identificativo del nostro cookie;
- il secondo specifica il valore del cookie;
- il terzo imposta la scadenza del cookie. Se non impostiamo una data di scadenza il coookie non scadrà;
Facciamo un esempio su come memorizzare il nome di un nostro utente (richiesto tramite un form) all'interno di in un cookie.
Ecco il codice:
<?
//recupero il nome dall querystring
$nome = $_GET['nome'];
//memorizzo il nome in un cookie
//ed imposto la scadenza tra un'ora...
setcookie("nome_utente", $nome, time()+3600);
?>
Ora che abbiamo memorizzato nel cookie il nome dell'utente potremo tranquillamente richiamarlo in tutte le nostre pagine PHP in questo modo:
<?
//recupero il valore del cookie...
$nome = $_COOKIE['nome_utente'];
//stampo a video il nome...
echo $nome;
?>
Se vogliamo cambiare il valore del nostro cookie basterà ripetere semplicemente l'operazione di assegnazione:
<?
//imposto come valore "pippo"
setcookie("nome_utente", "pippo");
//ho cambiato idea e imposto come "pluto"
setcookie("nome_utente", "pluto");
?>
Se invece vogliamo cancellare il cookie basterà richiamare il cookie senza specificare nessun valore:
setcookie("nome_utente");
oppure possiamo reimpostare la scadenza ad un momento passato, così:
setcookie("nome_utente", "pippo", time()-9999);
In entrambi i casi il cookie verrà cancellato.
Il comando setcookie() non vi garantisce la buona riuscita della vostra operazione. Il comando, precisamente, invierà le giuste intestazioni HTTP, poi spetta al client del vostro utente accettarle o meno. Quindi siete avvertiti...

E' possibile convertire una stringa di testo in minuscolo o in maiuscolo?
Sì. A qesto scopo soccorrono le funzioni strtolower() e strtoupper(). Precisamente:
Il seguente codice trasforma tutto il testo in minuscolo:
<?PHP
echo strtolower(‘MrWebMaster‘);
?>
Il seguente codice, invece, trasforma il testo in maiuscolo:
<?PHP
echo strtoupper(‘MrWebMaster‘);
?>

.htaccess
Imposta il file .htaccess per limitare l'accesso a cartelle del tuo spazio web
Per configurare un gruppo chiuso sul tuo spazio web, cioè accessibile attraverso l’inserimento di user-id e password devi utilizzare il file .htaccess
.htaccess ti permette di specificare l’accesso a una directory del tuo spazio subordinato all’ inserimento di user id e password.
Questa operazione è sconsigliata agli utenti meno esperti, in quanto presume una conoscenza di base dei protocolli di comunicazione.
Vediamo un esempio di file .htaccess per restringere l’accesso alla directory del mio dominio (miodominio.it) chiamata “privato”
Se creaiamo una cartella web col nome privato (www.miodominio.it/privato) e carichiamo dei contenuti, questi naturalmente sono visibili a tutti.
Ma se vogliamo subordinare la visualizzazione dei contenuti di questa cartella all’ inserimento di un nome utente e password dobbiamo creare un file .htaccess e .htpassword.
Questi file possono essere creati attraverso un semplice blocco note e devono essere poi caricati all’ interno della directory che intendiamo proteggere, nel nostro caso “privato”.
Un esempio di .htaccess
AuthType Basic
AuthUserFile /var/www/www.miodominio.it/httpdocs/privato/.htpasswd
AuthName "Area protetta"
require valid-user
Salviamo il file.
.htpasswd
nomeutente:password
Salviamo il file
Se caricate ora i due file nella cartella specificata noterete che tentando di connettersi a questa cartella verrà richiesto l’inserimento di un nome utente e di una password.

Proteggere le pagine senza MySQL
Un modo semplice ed efficace per proteggere un sito in PHP e' quello di creare una pagina, prima di quella da richiamare, dove venga chiesta una password. Supponiamo di aver creato una pagina che contiene i nostri dati anagrafici: 
dati.html
<HTML>
<HEAD>
<TITLE>Dati Anagrafici</TITLE>
</HEAD>
<BODY BGCOLOR=black TEXT=white>
<TABLE>
<TR>
<TD>Nome</TD>
<TD>Fabio</TD>
</TR>
<TR>
<TD>Cognome</TD>
<TD>Spinelli</TD>
</TR>
<TR>
<TD>Data nascita</TD>
<TD>3 marzo 1978</TD>
</TR>
<TR>
<TD>Luogo nascita</TD>
<TD>Lecco</TD>
</TR>
</TABLE>
</BODY>
</HTML>
Supponiamo di volerla proteggere, chiedendo prima una password. Per prima cosa prendiamo dati.html e lo ridenominiamo in dati.php
Come secondo passo aggiungiamo, prima di < TABLE> il seguente codice:
<FORM ACTION=dati.php METHOD=post>
Password: <INPUT TYPE=text NAME=pass SIZE=8 MAXLENGTH=8> 
<INPUT TYPE=submit VALUE='Entra'>
</FORM>
<?
if (!isset($pass)) $pass="";
if ($pass=="mypass") {
?>
e aggiungiamo, dopo </TABLE> ...
<?
} else echo "Password errata o non inserita.";
?>
Spieghiamo cosa accade...
La prima volta che apriamo dati.php la variabile $pass non e' valorizzata... quindi viene impostata a niente ("") da questa riga:
if (!isset($pass)) $pass="";
Subito dopo controlliamo che se la password e' corretta (in questo caso la password e' "mypass") mostriamo tutta la scheda anagrafica (e' stato sufficiente inserire il codice HTML fuori dai tag <? ?> e inclusi nelle parentesi grafe { } dell'istruzione if). In questo caso pero' $pass non e' ancora valorizzato e quindi non e' corretto... ci apparira' solo la videata di richiesta password e il messaggio "Password errata o non inserita."
Nel campo del form, inserendo la password corretta, quando premiamo il pulsante "Entra", viene ricaricata di nuovo la stessa pagina (clausola ACTION del tag FORM), solo che con il valore $pass (clausola NAME del tag INPUT TYPE=text) impostato a cio' che abbiamo scritto. Se $pass e' valida verra' mostrata la scheda.
Questo metodo, anche se spartano, protegge veramente le pagine perche' anche chiedendo al browser di visualizzare il sorgente HTML non sara' possibile vedere la password, che e' cablata sul sorgente PHP, che come ormai dovreste sapere, non e' visibile dal client che interroga il webserver.

Protezione password
Come proteggere un file attraverso la richiesta di user-id e password
Semplice script in php da includere su tutte le pagine web che si desidera proteggere con user-id e password
Se avete la necessità di rendere accessibile una o più pagine web solo attraverso l'inserimento di user-id e password, ecco un semplice script in PHP per la gestione delle pagine web protette.
Questo script va incluso su tutte le pagine web che desideriamo proteggere.
1. Creiamo il file autenticazione.inc.php
Aprire il block notes o un editor
Ecco il codice da inserire:
<?
if ( ( !isset( $PHP_AUTH_USER )) || (!isset($PHP_AUTH_PW))
|| ( $PHP_AUTH_USER != ’nomeutente’ ) || ( $PHP_AUTH_PW != ’password’ ) ) {
header( ’WWW-Authenticate: Basic realm="Nome sito"’ );
header( ’HTTP/1.0 401 Unauthorized’ );
echo ’Nome utente o password errati’;
exit;
}
?>
Sostituiamo a 'nomeutente' e 'password' il nomeutente e password che vogliamo scegliere per l'accesso alla pagina web protetta
Sostituiamo a 'Nome sito' il nome del nostro sito
Salviamo il file nomandolo autenticazione.inc.php
2. Includere il file autenticazione.inc.php sulle pagine web da proteggere
1. Condizione necessaria è che le pagine da proteggere abbiano estensione .php es miapagina.php
2. All' inizio della pagina inseriamo il seguente codice:
<? include(’autenticazione.inc.php’); ?>
3. Naturalmente, se il file autenticazione.inc.php è posizionato su un' altra cartella rispetto al file in oggetto, dovremo indicarne il percorso
4. Ripetere l'operazione per tutte le pagine che intendiamo proteggere
A questo punto, collegandoci alle pagine protette, ci verrà richiesto di inserire user-id e password

Creare una cartella e uploadare i files con relativa rinomina
Ho un form attraverso il quale seleziono un file... premendo SUBMIT carico una pagina PHP contenente uno script che provvede ad effettuarne l'upload sul server...
Quello che vorrei ottenere è:
1 - viene creata una cartella
2 - viene rinominato il file da uploadare
3 - l'upload del file rinominato viene fatto dentro la cartella creata
Ho usato un codice del tpo seguente:
mkdir(nomecartella);
rename(file);
copy ($HTTP_POST_FILES['file']['tmp_name'],"...public_html/immagini/".$HTTP_POST_FILES['file']['name']);
ma il file rinominato mi viene caricato fuori dalla cartella creata...
dunque mi chiedo: è possibile fare questo ? oppure il tempo che intercorre tra la creazione della cartella e l'istruz. copy è troppo breve ?
come posso ottenere alternativamente questo risultato ?
$nomecartella = "/ux01/0/172/public_html/immagini/".$codice;
mkdir($nomecartella);
if ($HTTP_POST_FILES['img1']['tmp_name'] != "") {
copy ($HTTP_POST_FILES['img1']['tmp_name'],"/ux01/0/172/public_html/immagini/".$HTTP_POST_FILES['img1']['name']);
Questo è il codice esatto che ho utilizzato: la creazione della cartella avviene, l'upload pure ma fuori dalla cartella creata.
Qualcuno sa indicarmi come posso modificarlo per ottenere l'effetto desiderato ?
Ok... ho risolto da solo:
$nomecartella = "/ux01/0/172/public_html/immagini/".$codice;
mkdir($nomecartella);
if ($HTTP_POST_FILES['img1']['tmp_name'] != "") {
copy ($HTTP_POST_FILES['img1']['tmp_name'],$nomecartella."/".$HTTP_POST_FILES['img1']['name']);

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. 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.

Scrivere il contenuto di una variabili in un file
// Come inserire un dato in un file!
function Write_to_file($text) {
$file = "file.txt";
$connect = @fopen($file, "a");
fputs($connect, $text.';', "4096");
fclose($connect);
echo 'Scrittura sul file avvenuta correttamente';
}
Write_to_file("Ciao a tutti!");
?>
Questo script scrive il contenuto della variabile $text alla fine di un file di testo file.txt, separando i vari valori con il simbolo ( ; ). Questo può essere cambiato secondo le proprie esigenze.
Il valore della funzione fputs (4096) indica il numero di byte (o di caratteri) memorizzabili in quel ciclo. Se volete aggiungere più caratteri nel file, cambiate questo valore.
Occhio: non troppo grande, altrimenti piantate il Web Server! 
OPPURE:
<? 
$testo="bla bla bla";
$file="cartella tua/filetesto.txt";
$fp=fopen($file , "w");
fwrite($fp , $testo);
fclose($fp);
?>

Le query SQL
Per selezionare i campi di un database si utilizza SELECT.
Se per esempio dovessimo estrarre il contenuto di tutti i campi di una tabella di nome "classe", dovremmo procedere in questo modo:
SELECT * FROM classe;
L'asterisco (*) ci consente di richiamare i campi senza specificare tutti i loro nomi.
Il termine FROM permette di identificare il nome della tabella dalla quale estrapolare i dati.
Se invece volessimo invece estrarre un solo campo useremmo il solo nome di quel campo, sarebbe difatti inutile estrarli tutti.
SELECT alunni FROM classe;
Se i campi fossero più di uno, è necessario separare i vari valori con una virgola (,) ad esempio:
SELECT alunni, voti FROM clienti;
Se però volessimo estrarre solo i nomi degli alunni con media uguale a 8 dovremo utilizzare la clausula WHERE:
SELECT alunni, media FROM classe WHERE media='8';
In questo modo, avremo come risultato solo i nomi degli alunni che hanno 8 come media.
Facendo riferimento all'esempio di prima, potremmo richiedere i nomi degli alunni che hanno una media pari a 8 e un totale di almeno 6 voti.
SELECT alunni, media, voti FROM classi WHERE media='8' AND voti<='6';
Il termine AND può essere tranquillamente sostituito da due e commerciali (&&).
Il termine OR, permette di creare un'alternativa.
SELECT alunni FROM classi WHERE media='7' OR voti>='3';
Il termine OR può essere sostituito dalle due barre verticali (||).
Per ordinare l'estrazione di una tabella, si può usare ORDER BY (si possono applicare i termini ASC dal più basso al più alto, è il default, e DESC il suo contrario).
SELECT * FROM classe ORDER BY media DESC;
In questo modo avremo i dati estratti in oriden decrescenti secondo la media di ogni alunno.
ASC e DESC funzionano anche con campi diversi dai campi di tipo INT o simili. In caso di campi di stringhe (TEXT, VARCHAR ecc.) seguiranno l'ordine alfabetico:
ASC dalla A alla Z.
DESC il contrario, dalla Z alla A.
Si possono ordinare i campi anche in base a più valori sempre utilizzano ORDER BY.

Operatori di ricerca di pattern
stringa LIKE pattern
Valutazioni di squenze di carattere o semplici pattern.
stringa REGEXP pattern oppure stringa RLIKE pattern
Confronto tra espressioni regolari.
BINARY stringa
Interpretazione binaria delle stringhe per confronti di tipo case-sensitive.
Espressioni regolari disponibili per REGEXP
.
Corrisponde a qualsiasi singolo carattere.
[...]
Corrisponde a qualsiasi carattere tra quelli che compaiono tra le parentesi quadre.
[^...]
Corrisponde a qualsiasi carattere diverso da quelli che compaiono tra le parentesi quadre.
^
Corrisponde all'inizio della stringa.
$
Corrisponde alla fine della stringa.
elemento
Corrisponde a "elemento".
elemento1 | elemento2
Corrisponde a "elemento1" o a "elemento 2".
elemento*
Corrisponde a zero o più occorrenze di "elemento".
elemento+
Corrisponde a una o più occorrenze di "elemento".
elemento?
Corrisponde a zero o a una occorrenza di "elemento".
elemento{n1}
Corrisponde esattamente a n1 occorrenze di "elemento".
elemento{n1,}
Corrisponde ad almeno n1 occorrenze di "elemento".
elemento{,n2}
Corrisponde a un numero di occorrenze di "elemento" compreso tra zero e n2.
elemento{n1,n2}
Corrisponde a un numero di occorrenze di "elemento" compreso tra n1 e n2.
()
Le parentesi consentono di raggruppare i pattern, con i pattern interni da valutare prima di quelli esterni.

Operatori logici
NOT espr oppure ! espr
Negazione logica.
espr1 OR espr2 oppure espr1 || espr2
Somma logica.
espr 1 AND espr2 oppure espr1 && espr2
Prodotto logico.

Funzioni logiche e condizionali
IF(espr1, espr2, espr3)
Dove se espr1 è vera la funzione restituisce espr2, se è falsa restituisce espr3.
IFNULL(espr1, espr2)
Se espr1 non è NULL la funzione restituisce espr1, in caso contrario restituisce espr2.
CASE valore WHEN [valore_di_confronto] THEN risultato2 ...] [ELSE risultato3] END
Effettua un test per verificare se valore coincide con uno dei possibili valori_di_confronto. Se coincide, la funzione restituisce il risultato corrispondente.

Funzioni stringa
LEFT(stringa, num) e RIGHT(stringa, num)
Restituiscono rispettivamente i num più a sinistra e più a destra della stringa.
LENGTH(stringa)
Determina la lunghezza della stringa.
SUBSTRING(stringa, posizione [,lunghezza])
Consente di estrarre dalla stringa tutti i caratteri che si trovano in una determinata posizione. Se invece si desidera ottenere un numero preciso di caratteri, è possibile utilizzare il parametro opzionale che specifica la lunghezza del pattern da estrarre.
CONCAT(stringa1, stringa2, ...)
Effettua una concatenazione di stringhe.

Mandare un mail in CC o BBC
$target = "to_email_address";
$subject = "subject_email";
$text = "email_message";
// Questa sono le righe che funzionano da
// intestazione alla mail
$header = "From: vostra@mail.it
Reply-To: vostra@mail.it
X-Mailer: PHP/4.0.2
bcc: indirizzo@dichivuoi.it, indirizzo2@dichivuoi.it
cc: indirizzo@veditu.it, indirizzo2@veditu.it";
// Le ultime due righe mandano la mail in CC o in BCC
// Funzione mail!
mail ($target,$subject,$text,$header);
?>
Per mandare un mail in CC o in BCC basta inserire due nuove righe nell'header della mail.
La differenza tra BCC e CC, è che in BCC i vari destinatari non possono visualizzare gli altri utenti a cui è stata mandata l'e-mail, invece in CC sì. 

Come spedire un' e-mail in formato HTML
$target = "to_email_address";
$subject = "subject_email";
$text = "email_message";
// Questa sono le righe che funzionano da
// intestazione alla mail
$header = "From: vostra@mail.it
Reply-To: vostra@mail.it
X-Mailer: PHP/4.0.2
Content-Type: text/html";
// Funzione mail!
mail ($target,$subject,$text,$header);

?>
Questo semplice codice spiega come spedire una mail in formato HTML. Tutto lo script sta nel Content-Type: text/html che definisce il formato della mail. E' ovvio che la variabile $text deve contenere codici HTML, o lo script risulta del tutto inutile! 

Come spedire un' e-mail con PHP
<?
// Codice di *esempio* per la spedizione di mail
// Queste variabili possono
// provenire anche da una form Web!
$to = "to_email_address";
$subject = "subject_email";
$message = "email_message";
// Funzione mail!
mail ($to, $subject, $message);
?>
Questo è il semplice codice di esempio per spedire una mail tramite PHP. E' importante notare che il file php.ini deve essere settato correttamente per operare in questo modo!!. 

Come ottimizzare le tabelle di un database MySQL
Queste poche righe di codice consentono di utilizzare OPTIMIZE TABLE, un programmino per ottimizzare le tabelle di un database MySQL(n.b. OPTIMIZE TABLE funziona solo con tabelle di tipo MyISAM o BDB).
Questo script è utile nel caso ci trovassimo ad utilizzare database di una certa grandezza, a cui abbiamo fatto aggiunte, cancellazioni o modifiche. Gli spazi vuoti verranno rimossi , e verrà riordinato l'indice del database stesso. Questo porterà consistenti guadagni in termini di spazio, velocità e prestazioni.
<?
$host = "host_database";
$user = "username";
$pass = "password";
$db_name = "nome_del_database";
$db = mysql_connect($host, $user, $pass);
mysql_select_db($db_name, $db);
echo "Ottimizzazione DataBase in corso...";
$SQL = "OPTIMIZE TABLE ";
$result = mysql_list_tables($DATABASE);
$i = 0;
while ($i < mysql_num_rows($result)) {
$name_table = mysql_table_name($result, $i);
echo "Ottimizzazione tabella: $name_table .....<BR>";
$SQL .= $name_table;
$SQL .= ",";
$i++;
}
$SQL = substr($SQL,0,strlen($SQL)-1); 
$result_set = mysql_query($SQL);
mysql_free_result($result_set);

?>
Basterà creare un file con estensione .php, copiare ed incollare questo codice, ed eseguirlo periodicamente.

Glossario di errori in PHP
Introduzione
Errori: che cosa significano? Iniziare lo studio di ogni tipo di linguaggio può essere frustrante; ci sono linguaggi più facili e più difficili, ma con nessuno si sfugge ai temuti errori. Si cercherà qui di chiarire il mistero di qualche errore comune in PHP.
Errori relativi a PHP
Il codice PHP è mostrato nella finestra del browser
Probabili cause:
1. l'estensione .php potrebbe non essere presente nel nome del file, quindi, è compilato come HTML regolare;
2. problemi con php.ini o il suo contenuto;
3. la pagina è visualizzata dal file system locale anziché dal server.
Erver o host non trovati
Probabili cause:
1. il server ha un conflitto DNS;
2. il server del database non è attivo.
Pagina non trovata
Probabili cause:
1. potrebbe essere sbagliata l'indicazione della directory nell'intero nome della pagina;
2. la pagina ha un'estensione sbagliata.
La pagina è bianca
Probabili cause:
1. il motore PHP ha dei problemi a compilare il codice con HTML associato allo script;
2. potrebbe mancare una chiusura di tag HTML;
3. il modulo PHP potrebbe non essere funzionante o PHP non è installato.
La pagina carica una finestra per il download di un file dal server
Probabile causa:
1. il server non è configurato per trattare i file di tipo o estensione .php.
Errore relativo a include o a file richiesto
Probabile causa:
1. l'indirizzo dell'include o il file specificato non è stato definito o specificato.
Il codice PHP è visibile nella finestra del browser
Probabile causa:
1. il codice non è tra i tag PHP.
I valori delle variabili non appaiono
Probabili cause:
1. il segno della variabile "$" non è presente;
2. i nomi delle variabili sono case-sensitive.
Parse errors
Probabili cause:
1. manca il punto e virgola ";";
2. mancano segni delle variabili "$";
3. mancano le parentesi graffe "{";
4. mancano le parentesi "(";
5. i quote non sono ignorati "\";
6. mancano gli include o i file richiesti.
Server errors
Probabile causa:
1. la pagina non ha permessi di lettura.
Function errors
Probabili cause:
1. la sintassi della funzione non è valida;
2. la funzione non è definita;
3. la funzione non esiste;
4. uso errato di funzioni built-in;
5. le funzioni definite dall'utente non producono avvisi di default.
Missing include file
Probabile causa:
1. il path dei file in include non è corretto.
La pagina impiega troppo tempo a caricare o il browser va in time-out
Probabili cause:
1. congestione della rete Internet con conseguente traffico rallentato;
2. troppo carico sul server;
3. il codice ha un loop infinito.

Estrapolare dei dati da un file esterno
<?
$file = "ciccio.txt";
$fd = fopen($file, "r");
$DATA = fgets($fd, 4096);
$data_exploded = explode("-", $DATA);
$num = count($data_exploded);
for ($i = ($num - 1); $i >= 0; $i--)
{
echo $data_exploded["$i"];
echo '
';
}
?>
Questa funzione mostra a video il contenuto di un file ciccio.txt strutturato in questo modo: DATO1-DATO2-DATO3-DATOn
La funzione è strutturata per un numero di dati infiniti, ma solo cambiando il valore 4096, che indica la quantità di memoria utilizzabile per quel processo. Vi consiglio di tenere questo valore sufficentemente basso per evitare di piantare il Web Server!

PHP: cos'e' e come funziona (http://www.guidainlinea.com/php/guida/base_1.asp)
Il linguaggio PHP, acronimo di Pre-Hypertext-Processor, è un linguaggio fortemente orientato al web che facilita la realizzazione di script e piccoli programmi utili per svolgere in maniera automatica e "lato-server" alcune funzioni che i webserver sono comunemente chiamati a svolgere.
Tramite questo linguaggio, semplice ma non banale (perlomeno non in tutti i suoi aspetti), è possibile realizzare pagine dinamiche, ovvero non staticamente scritte a priori ma adattabili a seconda delle esigenze dell'utente o di eventi esterni indecidibili al momento dello sviluppo.
Ad esempio con questo linguaggio è possibile realizzare pagine che "ricordano" il look scelto dall'utente (cioè fare quel che fanno tutti i portali, la customizzazione e personalizzazione del look), oppure pagine che permettono di inviare una mail in automatico senza utilizzare programmi esterni di posta elettronica, o ancora - motivo principale ma riduttivo per il quale il PHP è così utilizzato - interfacciarsi ad un DBMS (database management system) Ma questi non sono che i più comuni utilizzi di questo linguaggio! Come ogni linguaggio moderno che si rispetti, il PHP permette di utilizzare moduli esterni che permettono di fare tante altre funzioni: lavorare in maniera "trasparente" con l'XML, disegnare vere e proprie immagini (come ad esempio grafici o tabelle), recuperare files remoti come se fossero sul disco in locale, e ancora disegnare animazioni in Flash (!) o persino scrivere script di shell (per eseguire compiti che normalmente verrebbero affidati a complessi programmi in C o Perl) e via discorrendo.
PHP: ma cosa mi serve per farlo girare?
Iniziamo col dire che il PHP è un linguaggio interpretato e non compilato: questo significa che non produrrete alcun eseguibile perchè non potrete compilare il codice. Quel che potrete fare, una volta scritto il vostro primo script, sarà far eseguire questo codice da un altro programma (l'interprete) che, girando sulla macchina e solitamente sotto al web-server (e quindi compilato sulla piattaforma specifica), vi darà l'impressione che il vostro codice venga eseguito.
Disquisizioni tecniche a parte, moltissime sono le piattaforme oramai supportate. Qualunque UNIX flavour abbiate a disposizione o quasi qualunque macchina Windows oramai ha la disponibilità di installare un interprete del PHP. Per maggiori informazioni al riguardo vi rimando ai siti http://www.php.net/ e http://www.phpbuilder.com/ dove potrete trovare tutte le informazioni del caso e dove potrete trovare aiuto per l'installazione e la configurazione dell'interprete.
Per far girare i vostri scripts nel vostro spazio web (se disponete di un normale account di webhosting) dovrete controllare che venga supportato il PHP (e quale versione). Solitamente - ma non sempre - viene offerto anche almeno un database, solitamente sotto MySQL. Ci sono in rete alcuni spazi gratuiti su cui potrete fare le vostre prove. Downtimes a parte vi consigliamo http://www.f2s.com/ mentre per chi vuole spendere due lire consigliamo l'ottimo http://www.aletiahosting.com/ (i pacchetti partono da 9.95$ al mese con una miriade di opzioni ed una banda di tutto rispetto - un must per chi ama le soluzioni professionali senza spendere un occhio della testa)
Il primo Script
Come in ogni guida che si rispetti vediamo subito il nostro primo script:
<?PHP
/* questo e' un commento */
echo "Hello, world!";
?>
Rimanendo ovvio l'output di tale programma (e notando uno dei tanti metodi per inserire commenti nel codice), notiamo i tags "<?PHP" e "?>" (anche loro tra i tanti) che servono a dire all'interprete che il contenuto di tale sezione è da interpretare come codice PHP.
Notate come gli statement in PHP si concludano con il canonico punto e virgola (";")
Come lo chiamiamo lo script? Come vogliamo, ma di solito le estensioni interpretate senza ricorrere a particolari artifici degni di un hacker sono .php3 e .php.
Le variabili
In PHP le variabili non devono necessariamente essere dichiarate a priori e sono atipizzate. Questo significa che una variabile può contenere un intero, una stringa, un floating point o un valore booleano durante la sua esecuzione senza aver bisogno di essere ridichiarata ogni volta. La cosa curiosa è che persino un array può essere un mix di variabili di tipo diverso.
Le variabili in PHP si distinguono perchè incominciano con il simbolo di dollaro ("$") Gli assegnamenti sono contraddistinti dal simbolo di "=", come in C e Perl, mentre i simboli per i confronti sono:
< minore di > maggiore di <= minore o uguale a >= maggiore o uguale a != diverso da
Alcune utili funzioni legate alle variabili sono:
isset($variabile): restituisce "true" se la variabile $variabile è stata settata, false altrimenti
unset($variabile): "de-setta" la variabile $variabile, rendendola così di nuovo libera (utile per scripts computazionalmente pesanti)
Es.
<?PHP
$i = 3; /* assegna ad $i il valore 3 */
echo $i; /* stampa "3" */
$i = "casa"; /* adesso assegna ad $i il valore "casa" (vedi sopra: atipizzazione delle variabili) */
echo $i; /* stampa "casa" */
echo isset($i); /* stampa "true": la variabile $i è settata */
unset($i); /* la variabile $i adesso viene "de-settata" */
echo isset($i); /* stampa "false": la variabile $i non è più settata */
?>
Gli array, che possono essere a più dimensioni, sono indicati nella forma:
$array
come tutte le altre variabili. Per accedere al contenuto della $i-esima variabile dell'array si avrà una istruzione del tipo $array[$i - 1] (gli indici dell'array partono da 0 come in C).
Costrutti Fondamentali
Misto di Perl e C (ma anche Java per quel che riguarda le classi), il PHP trae il meglio da questi linguaggi risultando
sufficientemente performante ma soprattutto relativamente sicuro. I costrutti principali che non possono mancare nel
proprio know-how sono:
if-then-else
for
while
Chi conosce già altri linguaggi si senta libero di saltare alla sezione successiva dando magari una occhiata alla
sintassi di questi costrutti per avere una visione generale.
- IF-THEN-ELSE
Costrutto condizionale fondamentale, l'if-then-else in PHP ha questo aspetto (sintassi):
if (condition1) {
statement1;
}
else if (condition2) {
statement2;
}
[...]
else {
statement3;
}
Il risultato è il seguente: arrivati al primo "if" l'interprete valuterà l'espressione "condition1" e, se essa risulterà vera (ad es., se il numero 6 è diverso dal numero 5) allora eseguirà lo statement "statement1" In caso contrario passerà a valutare gli "if successivi" e, se nessuno dovesse essere verificato, eseguirà "statement3".
Notare che solo il primo "if" è necessario, gli altri sono opzionali. Notare inoltre che una volta preso un "ramo" del costrutto verrà eseguito SOLAMENTE quel blocco di istruzioni, saltando tutti gli altri. Notiamo anche che le parentesi graffe racchiudono un blocco di istruzioni. Nonostante siano superflue quando il blocco di istruzioni è rappresentato da una singola istruzione, è buona norma di programmazione racchiudere sempre le istruzioni tra parentesi graffe (in ogni linguaggio). In tal modo, a seguito di una aggiunta successiva, il risultato dello script sarà quello voluto, evitando noiosi e soprattutto costosi tempi morti di debugging nel caso si siano dimenticate le parentesi.
- FOR
Il ciclo "for" itera un dato blocco di istruzioni k volte. La sua sintassi è:
for (inizializzazione; condizione; incremento) {
blocco_di_istruzioni;
}
"inizializzazione" è una istruzione che inizializza una (o più) variabili; "condizione" è la condizione sulle variabili di inizializzazione che deve essere verificata perchè venga eseguito una volta ancora il ciclo; "incremento" è una espressione che incrementa una (o più) delle variabili di inizializzazione
Ricordando quanto detto sopra riguardo alle variabili, il seguente esempio stampa 4 volte la stringa "ciao":
<PHP
for ($i = 0; $i < 4; $i = $i + 1) {
echo "ciao\n";
}
?>
Il carattere "\n" rappresenta un newline, cioe' un carattere di "a capo"
Notate che l'istruzione
$i = $i + 1;
in PHP può essere abbreviata come
$i++; /* post-incremento: prima usa il valore, poi incrementa */
oppure come
++$i; /* pre-incremento: prima aumenta di uno, poi usa la variabile cosi' incrementata */
Le nozioni di pre-incremento e post-incremento sono superflue per gli scopi di questa guida. Ciò non significa che un buon programmatore non le sappia opportunamente usare, visto che sono presenti in quasi tutti i linguaggi di programmazione.
- WHILE
Il ciclo "while" permette maggiore flessibilità del ciclo "for" in quanto il controllo sulla condizione non è "fisso", cioè basato su un incremento di una variabile, ma può essere molto più "flessibile", in relazione a particolari condizioni che si possono verificare sui dati.
La sua sintassi è:
while (condition) {
statement;
}
e la sua semantica è la seguente: esegui "statement" fintantochè la condizione "condition" è verificata.
Es.
<?PHP
$i = 0;
while ($i < 6) {
echo $i;
$i++;
}
?>
Funzioni in PHP
Come in ogni linguaggio, anche in PHP è possibile crearsi delle proprie funzioni, utili per compiti ripetitivi o che possono essere visti come tali (magari con un po' di immaginazione, specializzando un po' la funzione e rendendone l'esecuzione sensibile al valore dei parametri)
La sintassi è:
function nome_funzione(parametri_opzionali) {
corpo_della_funzione;
}
I parametri sono opzionali e possono venire specificati o meno al momento della chiamata. In particolare suggeriamo di richiamare sempre le funzioni con tutti i loro parametri (onde evitare spiacevoli inconvenienti ed errori apparentemente inspiegabili). Se si ha la necessità di specificare un parametro che solo ogni tanto può venire usato si può utilizzare la seguente notazione:
Es.
<?PHP
function mia($a, $b, $c = "ciao") {
/* bla bla bla */
}
mia("pippo", "pluto", "paperino"); /* in questo caso $a prende il valore "pippo", $b "pluto" e $c "paperino" */
mia("pippo", "pluto"); /* in questo caso $a prende il valore "pippo",
$b "pluto" e $c "ciao" (valore di default) */
?>
E ORA?
A questo punto sappiamo per sommi capi la sintassi del PHP e quindi ci possiamo addentrare alla scoperta delle funzioni che questo linguaggio ci offre e sviluppare qualche esempio per capire effettivamente come ci può venire incontro tale linguaggio nel nostro compito di webmasters in un mondo che ogni giorno diventa sempre più competitivo. Daremo per scontato che sappiate la sintassi del linguaggio HTML per lo sviluppo delle pagine web e svilupperemo insieme alcuni piccoli script che ci permetteranno di inserire sul nostro sito alcuni "gadgets tecnologici" molto
Filesystem
Introduciamo ora qualche funzione che ci può venire in aiuto quando dobbiamo manipolare files presenti sul nostro spazio web oppure vogliamo recuperare files da remoto.
Il PHP, rispetto ad altri linguaggi, permette infatti con una singola chiamata non solo di recuperare (e quindi poter leggere/scrivere) un file locale, ma anche di recuperare un file che sia su un altro spazio web oppure su un server FTP in maniera trasparente, vale a dire senza dover utilizzare altre chiamate.
* fopen()
Anzitutto, prima di poter leggere o scrivere un file è necessario aprirlo. Questa funzione, che accetta due parametri di input (il nome del file e il tipo di operazione - lettura/scrittura/append e altre combinazioni) ritorna il descrittore del file, descrittore che utilizzeremo per fare le altre successive operazioni.
Questa funzione, come già anticipato, permette di aprire anche un file remoto messo su uno spazio web (e quindi recuperabile tramite il protocollo HTTP) o su server FTP; tutto questo permanendo identica la sintassi: la funzione si comporterà diversamente a seconda del nome di file passatole (se inizierà con http:// tenterà di recuperare il file dal webserver remoto; se inizierà per ftp:// tenterà di prenderlo dal server FTP remoto; altrimenti lo considererà come un file locale).
Le modalità di apertura di un file sono le seguenti:
'r' - apre il file per la sola lettura e sistema la "testina" di lettura all'inizio del file
'r+' - apre il file per lettura/scrittura, posizionando la testina all'inizio del file
'w' - apre il file per la scrittura, troncandone il contenuto se esiste; se non esiste tenta di crearlo; mette la testina all'inizio
'w+' - idem come 'w', ma lo apre per la lettura/scrittura
'a' - apre il file per la sola scrittura, mettendo però la testina a fine file
'a+' - come sopra, ma lo apre per la lettura/scrittura
Es.
$fp = fopen("/home/marco/file.txt", "r");
$fp = fopen("http://www.sito.com/", "r");
$fp = fopen("ftp://user:password@sito.com/", "w");
($fp è quello che viene chiamato "file handle" o, in italiano, "descrittore di file")
* fgets()
Questa chiamata permette di leggere da un file aperto un certo numero di caratteri specificati. Tale funzione ha la particolarità di terminare prima di aver letto i caratteri specificati se incontra un newline (o un "fine file")
Utile per la lettura di linee singole da un file
* fputs()
Opposto della funzione fgets(), questa chiamata permette di scrivere in un file una data stringa. La posizione nella quale tale stringa verrà scritta dipende solamente dalla posizione corrente della testina di scrittura.
* fseek()
Questa funzione permette di spostare la testina di lettura/scrittura del file corrente in una certa posizione. Accetta in input due parametri: il descrittore di file e la posizione.
Notare che non funziona su files remoti (http:// o ftp://) ma solo su files locali
* fclose()
Chiude il descrittore di file passatole
Il seguente esempio esegue una copia di un file in un altro (esempio puramente didattico: in PHP esiste la funzione copy() che esegue la copia di due files):
Es.
<?PHP
$fp1 = fopen('leggi.txt', 'r');
$fp2 = fopen('scrivi.txt', 'w');
while ($buf = fgets($fp1, 4096)) {
fputs($fp2, $buf);
}
fclose($fp1);
fclose($fp2);
?>
Funzioni per manipolare le stringhe
Vediamo ora qualche utile funzione corredata da esempi per utilizzare al meglio le stringhe all'interno dei nostri programmi. Il PHP, al contrario del C ad esempio, offre una visione "ad alto livello" di questi oggetti usati ogni giorno dai programmatori e pertanto non permette (escludendo bachi nell'interprete) buffer overflows e problemi simili legati alla gestione di stringhe come arrays (vedi il linguaggio C).
* explode()
Questa funzione "esplode" una stringa dividendola in più parti secondo un dato separatore. Il suo risultato è un array.
Vediamone subito un esempio:
<?PHP
$stringa = "parte1 parte2 parte3 parte4 parte5 parte6";
$array = explode(" ", $stringa);
?>
* htmlentities()
Questa funzione serve per "escapare" i metacaratteri HTML in una data stringa. Quel che fa in pratica è sostituire ad una stringa ASCII le corrispondenti entità HTML (ove definite)
Risulta preziosa quando si desidera scrivere in una pagina web l'input dell'utente
Es.
<?PHP
htmlentities("àèìòù");
?>
restituirà in output la stringa:
&agrave;&egrave;&igrave;&ograve;&ugrave;
* print()
La funzione print() è analoga alla funzione echo e, come essa, stampa a video la stringa datale in input
* substr()
La funzione substr() ritorna una sottostringa della stringa datale in input. Senza sviscerare tutta la sintassi di questa funzione (relativamente complessa rispetto alle altre) diciamo che in input accetta, oltre alla stringa in esame, due interi: la posizione di inizio e quella di fine della sottostringa da estrarre.
Restituisce in output la sottostringa cercata.
Ricordiamo che l'indice della prima posizione di una stringa è 0 e non 1.
Es.
<?PHP
echo substr("abcdef", 1, 3);
?>
dà in output:
bcd
* trim()
La funzione trim() ritorna la stringa datale in input senza gli spazi iniziali e finali. Utile quando si desiderano eliminare tali valori da un input dell'utente
Finalmente DataBase
Dopo aver visto alcune utili funzioni che ci permetteranno di essere più flessibili nella scrittura dei nostri scripts, vediamo finalmente come ci possiamo interfacciare ad un database tramite il PHP, ragione per la quale il PHP è così tanto amato ed utilizzato.
Il PHP dispone di un supporto eccezionale verso la maggior parte dei DBMS (database management system) commerciali e non e permette di interfacciarsi ad essi in maniera semplice e - soprattutto - parametrizzabile. Questo significa che potremo (anzi: da buoni programmatori dovremo!) scrivere una serie di funzioni utili per la nostra applicazione, inserirle in una classe (probabile argomento futuro) o in un file ad hoc ed utilizzare questi nuovi prototipi per scrivere il nostro codice. Questo ci permetterà di dover cambiare solo quelle funzioni che si interfacciano al database un giorno che dovessimo per una qualunque ragione cambiare il nostro DBMS in backend, risparmiandoci bachi nel codice, tempo e fatica, e quindi soldi.
In questa panoramica utilizzeremo le chiamate a MySQL, diffusissimo DBMS noto per la sua leggerezza e velocità. Tale DBMS non è adatto ad ogni tipo di applicazioni, anzi è molto ristretto (e proprio per questo veloce), ma ben si adatta ai compiti normalmente svolti e svolgibili su web. I più svezzati tra voi si scordino triggers, stored procedures e subselects. Con MySQL sono un lontano ricordo: un prezzo da pagare per la velocità offerta rispetto agli altri DBMS.
Connessione e Disconnessione da un database
Come per i files, anche per i databases è necessario instaurare una connessione al DBMS e, per fare i "programmatori puliti" in perfetto stile UNIX, rilasciarla quando essa non risulta più necessaria.
Una premessa è però necessaria: dal momento che in un DBMS possono essere immagazzinati dati di varia natura e provenienti magari da diversi dipartimenti (nel caso di un'azienda) o da diversi utenti (tipico nel mondo del webhosting) è necessario che vi sia un metodo basato sull'autentifica degli utenti in base a credenziali (nome utenti e password principalmente, ma anche nome di host)
Senza scendere troppo nei dettagli vi ricordiamo soltanto che sarà necessario avere il nome utente e la password prima di potersi collegare ad un database.
$link = mysql_connect($host, $user, $pass); è la chiamata per instaurare una connessione (non persistente) ad un DBMS. Questa funzione, analogamente alla chiamata fopen() vista in un articolo precedente, ritorna un descrittore, qui chiamato "link" che identifica la connessione. Dopo aver fatto le nostre query e le nostre transazioni tramite le chiamate che vedremo successivamente utilizzeremo la chiamata mysql_close($link); per liberare le risorse e chiudere correttamente la nostra connessione.
Questo non è l'unico modo per instaurare una connessione con MySQL, nè necessariamente il più performante. Tuttavia può essere a volta l'unico metodo funzionante (dipende essenzialmente dalla configurazione del server) e quindi sarà l'unico illustrato. Chi è interessato può provare a cercare sulla Reference Guide del PHP la funzione "mysql_pconnect"
Cambiare (o settare) il database!
- Query
Solitamente una connessione viene instaurata per eseguire poi delle query alla nostra base di dati. Per tale compito ci viene in aiuto la funzione mysql_query($query, $link) che permette di eseguire la query $query utilizzando il link (già aperto) $link
La query può essere di un qualunque tipo di quelle accettate dal DBMS, e può essere ovviamente parametrizzata con le nostre variabili.
La funzione mysql_query ritorna un valore, "result", che sarà molto importante in talune circostanze, come vedremo in seguito. Nel caso la query fallisca ritornerà un valore logico "false", utile per diagnosticare eventuali problemi.
- Recuperare valori dal database
Spesso e volentieri sarà necessario recuperare alcuni valori dalla base di dati. Questo sarà tanto più vero quando avremo eseguito una SELECT sulla base di dati e vorremo vedere quali valori ci vengono riportati.
Per fare ciò si possono utilizzare tante funzioni, ciascuna più o meno specializzata in alcuni compiti. Quella più utile risulta però essere la funzione mysql_fetch_array($result) che, preso in input il "result" visto nel paragrafo prima (vi ricordate che avevamo detto che serviva?) restituisce un array contenente, componente per componente, la riga attuale nel database.
Più chiamate a questa funzione restituiscono righe differenti (questo ovviamente finchè ce ne sono; quando non ce ne sono più restituisce "false")
- Ma quante righe ci sono nel database?
Se vogliamo stabilire quante righe ha generato la nostra SELECT possiamo utilizzare la query mysql_num_rows($result) (notate, una volta ancora, l'importanza di $result) che ci restituisce il numero di righe presente nel set del risultato
- Liberare i risultati: una buona pratica
Abbiamo già visto quanto sia importante, per script computazionalmente pesanti, liberare variabili PHP tramite la chiamata unset()
In caso di set molto grossi è buona pratica utilizzare la chiamata mysql_free_result($result) dopo aver terminato il nostro lavoro su tale set.
Un esempio chiarificatore
Vediamo qui di seguito un esempio che schiarirà certamente le idee:
Es.
<?PHP
/* si collega al DBMS */
$link = mysql_connect($host, $user, $password);
/* cambia il database corrente, impostandolo a "database" */
mysql_select_db("database", $link);
/* esegue una query SELECT per recuperare ogni valore presente nella tabella "table" (la tabella sta nel
database corrente) */
$result = mysql_query("SELECT * FROM table", $link);
/* esegue un ciclo while che permette di recuperare tutte le righe; mette in particolare la riga corrente nell'array
$row */
while ($row = mysql_fetch_array($result)) {
/* stampa alcuni valori */
echo $row["user_id"] . " <-> " . $row["fullname"] . "<BR>";
}
/* stampa il numero di righe presenti nel set */
echo mysql_num_rows($result) . "<BR>";
/* libera il set di risultati - buona pratica */
mysql_free_result($result);
/* chiude la connessione al DBMS - buona pratica */
mysql_close($link);
?>
Esempi utili per approfondire
In questa sezione presenteremo qualche esempio semplice che può tornare utile nella vita di ogni webmaster quando deve realizzare una nuova sezione dinamica per un sito. Questi esempi, volutamente non complicati, hanno lo scopo di chiarire ulteriormente le idee e presentare un approccio utile alla risoluzione di compiti comuni.
- SPEDIRE UNA MAIL
Capita spesso che l'unico modo offerto per spedire il proprio feedback ad un dato sito sia scrivere una mail tramite il classico programma di posta. Tuttavia, per fornire una visione più professionale del nostro servizio (specie se è un servizio a pagamento) risulta utile realizzare una piccola interfaccia customer-care che permetta all'utente di mandarci le sue impressioni senza per questo dover uscire dal programma che sta attualmente utilizzando - vale a dire il browser. Questo esempio illustra come realizzare un piccolo form in HTML senza fronzoli inutili adatto allo scopo. Il codice è ben commentato e dovrebbe chiarire il senso del programma:
Es.
<HTML>
<HEAD>
<TITLE>Contattaci</TITLE>
</HEAD>
<BODY>
<?PHP
/* $chi, $autore e $msg vengono settate se si è cliccato sul pulsante "invia" del form; questo accade
per tutte le variabili inserite all'interno di un form: esse prendono il nome che avevano nel controllo del form.
La cosa interessante e' che questa sezione sara' saltata completamente la prima volta che questo file verra' caricato,
in quanto le variabili $chi, $autore e $msg non saranno ancora state inizializzate. Questo e' utile per mandare in
output il solo codice HTML del form */
if (isset($chi) && isset($autore) && isset($msg)) {
/* discriminiamo a seconda del valore di $chi e spediamo una mail a chi appropriato */
if ($chi == "vendite") {
/* parametri della funzione mail(): a chi, titolo, testo, headers addizionali (vedi RFC822) */
mail("vendite@sito.com", "mail dal web", "$msg", "From: $autore");
}
else {
mail("tecnici@sito.com", "mail dal web", "$msg", "From: $autore");
}
/* manda in output un ringraziamento che verra' inserito prima del codice del form */
echo "Mail spedita. Grazie!<BR><BR>\n";
}
/* qui si conclude una parte del codice PHP. Quel che segue e' codice HTML, salvo la sezione introdotta da <?PHP e
chiusa da ?> che contiene un solo comando: echo $PHP_SELF;
$PHP_SELF e' una variabile automatica (cioe' generata dal PHP in maniera automatica) che contiene semplicemente il
nome (piu' l'eventuale percorso) dello script corrente. In questo modo indichiamo al browser dell'utente dove deve
venir spedito il contenuto del form dopo che l'utente ha cliccato su "invia" */
?>
<FORM action="<?PHP echo $PHP_SELF; ?>" method="post">
<INPUT type="text" name="autore" value="tua@email">
<SELECT name="chi">
<OPTION value="vendite">ufficio vendite</OPTION>
<OPTION value="tecnici">ufficio tecnico</OPTION>
</SELECT>
<TEXTAREA name="msg" rows="10" cols="50">messaggio</TEXTAREA>
<INPUT type="submit" value="invia">
</FORM>
</BODY>
</HTML>
- REALIZZARE UN SEMPLICE GUESTBOOK
In questo esempio vedremo invece come interfacciarci ad un database (MySQL nel nostro caso) per realizzare una piccola applicazione di guestbook nella quale gli utenti possano inserire i loro commenti sul nostro sito web. Ancora una volta non sarà il codice HTML ad essere approfondito, ma solamente il codice PHP.
Useremo ciò che abbiamo imparato nella sezione dedicata ai databases per instaurare la connessione ed eseguire le queries appropriate, rilasciando la connessione quando non più utile. Ecco l'esempio, come al solito ben commentato:
Es.
<HTML>
<HEAD>
<TITLE>Guestbook</TITLE>
</HEAD>
<BODY>
<?PHP
/* Come nell'altro esempio (infatti questo guestbook e' molto simile alla spedizione della mail) la sezione che
segue verra' valutata solamente dopo che l'utente avra' cliccato sul pulsante "invia", quindi almeno al secondo
caricamento di questo script */
if (isset($autore) && isset($msg)) {
/* instaura una connessione al DBMS e seleziona il database corrente */
$link = mysql_connect("localhost", "utente_database", "segreto");
mysql_select_db("database", $link);
/* inserisce il commento e l'email di chi l'ha scritto nel guestbook */
mysql_query("INSERT INTO guestbook (autore, msg) VALUES ('$autore', '$msg')", $link);
/* manda in output un ringraziamento che verra' inserito prima del codice del form */
echo "Commento inserito. Grazie!<BR><BR>\n";
}
/* qui si conclude una parte del codice PHP. Quel che segue e' codice HTML, salvo la sezione introdotta da <?PHP e
chiusa da ?> che contiene un solo comando: echo $PHP_SELF;
$PHP_SELF e' una variabile automatica (cioe' generata dal PHP in maniera automatica) che contiene semplicemente il
nome (piu' l'eventuale percorso) dello script corrente. In questo modo indichiamo al browser dell'utente dove deve
venir spedito il contenuto del form dopo che l'utente ha cliccato su "invia" */
?>
<FORM action="<?PHP echo $PHP_SELF; ?>" method="post">
<INPUT type="text" name="autore" value="tua@email">
<TEXTAREA name="msg" rows="10" cols="50">messaggio</TEXTAREA>
<INPUT type="submit" value="invia">
</FORM>
Commenti già inseriti:<BR>
<?PHP
/* qui inseriamo ora tutti i commenti giunti finora. Vale la pena di spiegare l'utilizzo della funzione htmlentities():
questa funzione traduce semplicemente i caratteri di un testo ASCII che non possono essere scritti "così come sono"
in un file HTML, trasformandoli in entità. Vale a dire che, ad esempio, il carattere "à" verra' tradotto nella stringa
"&agrave;" e cosi' via */
$result = mysql_query("SELECT * FROM guestbook", $link);
/* esegue un ciclo while che permette di recuperare tutte le righe, cioe' tutti i commenti; mette in particolare la
riga corrente nell'array $row */
while ($row = mysql_fetch_array($result)) {
/* stampa i valori trovati, facendo cura di utilizzare la funzione htmlentities() introdotta sopra */
echo "<B><A href=\"mailto:" . htmlentities($row["autore"]) .
"\">" . htmlentities($row["autore"]) . "</A></B>: " . htmlentitites($row["msg"]) . "<BR>\n";
}
/* rilascia la connessione al DBMS */
mysql_close($link);
?>
</BODY>
</HTML>
Usare utilmente il linguaggio (http://www.guidainlinea.com/php/guida/av_1.asp)
In questa piccola guida vedremo alcuni aspetti del PHP strani, utili, divertenti. Il PHP non è solo un linguaggio per il web ma è un linguaggio sufficientemente potente da poter essere paragonato a C e Perl vista la quantità di funzioni che mette a disposizione.
Come il Perl, tra l'altro, il PHP permette di essere eseguito "da shell", vale a dire che si può (sotto determinare condizioni) lanciare uno script in PHP tramite l'interprete e così simulare l'esecuzione di uno script di shell.
Proprio per questo motivo nelle ultime versioni sono state aggiunte funzioni esclusivamente rivolte a questo scopo, come ad esempio la famosissima GNU readline() per leggere input da tastiera (funzione che risulta evidentemente inutile in un ambito di applicazione web)
Avventuriamoci quindi alla scoperta dei 1000 usi ed costumi di questo flessibilissimo linguaggio!
Regular Expressons (Regexps)
Le regular expressions (in italiano: espressioni regolari) sono un utilissimo strumento per tutti coloro che si trovano a manipolare del testo "più o meno" formattato proveniente da certe sorgenti.
Facciamo un esempio: un file HTML è un tipico esempio di testo formattato in quanto i files scritti in questo linguaggio devono essere sintatticamente corretti (in realtà questo non è verissimo per l'HTML, ma assumeremo per semplicità che sia così). Supponiamo di avere una lista di URLs che dobbiamo leggere e dalle quali dobbiamo estrapolare, ad esempio, tutti i tags <TITLE> (uno per file). Come fare? La prima parte è semplice: sarà sufficiente ciclare sulla lista (magari contenuta in un array, oppure richiesta ad un database) e aprire una connessione tramite la funzione fopen() verso la pagina desiderata e quindi leggere il testo con la funzione fgets() salvando tutto in un file. Difficoltà maggiori si avranno nell'estrapolare invece i tags richiesti, in quanto la loro posizione non è nota a priori ed inoltre possono essere presenti in varia forma (ci possono essere degli "a capo", oppure degli spazi, etc.). Come fare allora? Semplice, tramite le regexp! Le regexp hanno infatti la capacità di adattarsi perfettamente al testo e permettono di specificare precisi patterns di ricerca (anche condizionali, cioè basati sul quello che si è già letto). Il PHP supporta due tipi differenti di regexp: quelle "native" del linguaggio (che andremo a vedere: POSIX extended regular expressions) e quelle "Perl-like", più flessibili ma anche più complicate. Tra le funzioni per manipolare le regexp ne segnaliamo due: eregi() ed eregi_replace() che rispettivamente cercano un testo (case insensitive) e che cercano e sostituiscono un testo (sempre case insensitive) Come in tutte le regexp anche in quelle del PHP ci sono dei metacaratteri che significano qualcosa per l'interprete. Tra di essi citiamo:
$ indica la fine della stringa
^ indica l'inizio della stringa, a meno che non sia inserita in [] (in questo caso indica la negazione dei caratteri
ivi presenti)
| indica una possibile scelta (OR)
[] racchiude una sequenza di caratteri
Es.
<?PHP
ereg("abc", $stringa);
/* ritorna "vero" se la stringa abc è presente in $stringa */
ereg("^abc", $stringa);
/* ritorna "vero" se la stringa abc è presente all'inizio di $stringa */
ereg("abc$", $stringa);
/* ritorna "vero" se la stringa abc è presente alla fine di $stringa */
eregi("(ozilla.[23]|MSIE.3)", getenv("HTTP_USER_AGENT"));
/* ritorna "vero" se il browser e' Netscape 2 o 3 oppure Internet Explorer 3 */
?>
Nel caso si voglia invece cercare del testo per modificarlo allora sarà necessario utilizzare l'altra funzione vista, che ha una sintassi molto intuitiva come si vede da questi esempi:
<?PHP
$string = ereg_replace("^", "<BR>", $stringa);
/* inserisce un <BR> all'inizio di $stringa */
$string = ereg_replace("$", "<BR>", $string);
/* inserisce un <BR> alla fine di $stringa */
$string = ereg_replace("\n", "", $string);
/* elimina le occorrenze del carattere \n */
?>
Cookie
In PHP è naturalmente possibile gestire i cookies, informazioni salvate sulla macchina dell'utente dal sito web che si sta visitando per uso futuro. Non ci addentreremo in problematiche di privacy e neppure in una descrizione di cosa sono i cookies e come funzionano: per questo vi rimandiamo alle guide in rete e in particolare all'indirizzo http://www.cookiecentral.com/
Il PHP mette a disposizione dello sviluppatore una utile funzione, setcookie(), che permette di fare tutto quel che si può fare con i cookies: settarne uno oppure cancellarlo.
Per accedere ad un cookie nella maggior parte delle installazioni è sufficiente utilizzare il nome del cookie preceduto dal simbolo di dollaro, esattamente come se fosse una variabile passata allo script (ed in effetti è proprio così)
La funzione setcookie() dispone di ben 6 campi ma nella maggior parte degli utilizzi sarà sufficiente specificare i primi 3.
La sintassi è:
int setcookie(string name, string value, int expire, string path, string domain, int secure);
Anzitutto va notato che prima di spedire un cookie è necessario non aver scritto nulla in output, pena un messaggio di warning da parte del PHP. Infatti, secondo il protocollo HTTP, i cookies devono essere passati negli headers della pagina.
Per cancellare un cookie sarà sufficiente richiamare la funzione setcookie() passandole solamente il primo argomento, e cioè il nome del cookie da cancellare dal browser dell'utente.
Per spedire invece un cookie ci sono vari modi:
<?PHP
setcookie("testcookie", "valore"); /* imposta il cookie nella maniera piu' semplice possibile */
setcookie("testcookie", "valore", time() + 3600); /* "spira in" 1 ora */
setcookie("testcookie", "valore", time() + 3600, "/"); /* "spira" in 1 ora e lo imposta come leggibile da tutte le pagine
del sito (il suo path viene impostato sulla root del webserver) */
echo $testcookie; /* stampa il valore del cookie $testcookie */
?>
Per maggior informazioni sui cookies vi rimandiamo in rete ai siti già citati o all'indirizzo http://www.netscape.com/newsref/std/cookie_spec.html .
Sockets
Il PHP fornisce il supporto per le sockets TCP e di dominio Unix. Tratteremo qui il primo tipo, essendo maggiormente utile.
Tramite le sockets, come il lettore di questa guida saprà, è possibile instaurare una connessione ad un host remoto tramite la rete. Le sockets TCP in particolare garantiscono la correttezza dello stream di dati, eliminando problemi derivanti da duplicati e pacchetti persi.
Tramite il PHP risulta pertanto facile realizzare un client di un qualunque servizio TCP di rete che si collega ai vari hosts ed esegue alcune procedure. In rete si trovano migliaia di esempi, uno dei quali è quello di controllare la correttezza dell'indirizzo email inserito dall'utente.
Un modo molto semplice per capire come funzionano le sockets risulta quello di creare un piccolo client HTTP che richiede una pagina ad un host e la mostra a video. Per far ciò sarebbe possibile, come abbiamo già visto, utilizzare la funzione fopen() con il nome dell'URL da recuperare ma andremo qui ad illustrare l'altro approccio possibile basato su sockets, decisamente più flessibile. Il codice è ben commentato e non necessita pertanto di ulteriori spiegazioni. L'esempio è stato recuperato dal "PHP manual" e leggermente modificato:
<?PHP
/* apre una connessione verso www.php.net, porta 80 */
$fp = fsockopen("www.php.net", 80);
/* se $fp non e' un file descriptor valido esce */
if(!$fp) {
exit();
}
else {
/* scrive sulla socket la richiesta HTTP (vedi RFC relativa) */
fputs($fp,"GET / HTTP/1.0\n\n");
/* legge ora i dati indietro dalla socket fintantoche' non e' finito lo stream di dati */
while(!feof($fp)) {
/* scrive in output cio' che legge mano a mano che lo fa */
echo fgets($fp, 128);
}
fclose($fp);
}
?>
MySQL Persistent connections
In PHP come abbiamo già visto è presente il supporto nativo per il DBMS MySQL, database ampiamente utilizzato in rete in quanto molto veloce anche se povero di funzionalità che risultano però superflue in un contesto di applicazione web (questo, almeno, nella maggioranza dei casi)
In PHP non è possibile solamente collegarsi a MySQL ogni volta tramite una connessione creata ad hoc, ma è anche possibile cercare di riutilizzare una connessione instaurata in precedenza, il tutto al fine di velocizzare gli accessi riducendo l'overhead richiesto per la connessione (che ricordiamo ai più svezzati essere una connessione tramite socket TCP e che pertanto richiede il three-way handshake con tutto il conseguente carico)
Per sfruttare le connessioni persistenti sarà sufficiente:
sostituire nel codice le chiamate mysql_connect() con la chiamata mysql_pconnect() con eguale sintassi per quel che riguarda i parametri
rimuovere le chiamate mysql_close() in quanto le connessioni dovranno rimanere aperte
Fatto questo il sistema sfrutterà appieno la funzionalità di connessioni persistenti, ammesso che il sistema in uso sia configurato per farlo (alle volte potrebbero verificarsi errori apparentemente inspiegabili se si usano, anche se è abbastanza raro; in tal caso sarà necessario tornare alle vecchie connessioni "usa e getta").
4. Come si visualizza la data?
Ci sono molti di visualizzare una data in PHP. Uno di questi è il seguente:
<?PHP
/* visualizza una data del tipo: 31 luglio 2001 */
echo date("H:i:s d/m/Y");
?>
Come faccio a trasformare una stringa da maiuscolo a minuscolo e viceversa?
Puoi usare rispettivamente le funzioni strtolower() e strtoupper() passandogli come argomento la stringa da convertire. E' ovvio che se la stringa è già minuscola/maiuscola rimarrà come tale (ti viene restituita dalla chiamata).
Es.
<?PHP
echo strtolower('Pippo'); /* scrive pippo */
echo strtolower('pippo'); /* scrive ancora pippo (la stringa era già minuscola) */
?>
15. Installazione PHP: come modulo di Apache o come CGI?
Ci sono vantaggi e svantaggi ad entrambi gli approcci (non avrebbero senso di esistere entrambi altrimenti)
Nel primo caso la risposta del webserver sarà migliore in quanto ad ogni richiesta non verrà creato un nuovo processo in quanto il modulo - statico o dinamico - sarà caricato insieme ad Apache e pertanto risponderà lui alla interpretazione degli scripts. Tuttavia in questo caso non potrai eseguire scripts PHP da shell, come visto invece prima.
Nell'altro caso, a scapito delle performances (ogni script che gira sarà un nuovo processo), avrai la possibilità di eseguire gli scripts anche da shell, il che può essere utile in certi casi.
Ti consigliamo comunque di reperire maggiori informazioni prima di installare il PHP come modulo CGI: infatti in questa "versione" il PHP è maggiormente soggetto a pericolosi problemi di sicurezza.

Creare un catalogo immagini automatico con PHP
Vedremo come creare dinamicamente un catalogo di immagini che visualizzi automaticamente tutte le immagini presenti della directory "foto" del nostro sito.
Unico presupposto dello script è, pertanto, l'esistenza di una directory "foto" contenente esclusivamente dei file di immagine.
Create quindi nella root del vs. sito la cartella "foto" e metteteci dentro qualche file d'immagine. Ecco il codice da salvare come "galleria.php":
<?
// Definisco il percorso della mia directory immagini
$img_dir = "./foto";
// Utilizzo opendir per aprire la directory
$handle = opendir($img_dir);
print "<center><table>";
// Creo un ciclo ed utilizzo readdir per esplorare il contenuto della directory
while (false !== ($files = readdir($handle)))
{
// Visualizzo le immagini...
if ($files != "." && $files != "..")
{
print "<tr><td><img src=$img_dir/$files></td></tr>";
}
}
print "</table></center>";
?>
Il motore dello script, si basa su due funzioni native del php: opendir e readdir che hanno la funzione rispettivamente di aprire e leggere la directory specificata.
Dopodichè abbiamo utilizzato un ciclo while per stampare a video tutte le occorrenze trovate.

Files dentro a MySQL ( http://freephp.html.it/articoli/print_articolo.asp?id=73 )
Introduzione
Credo sia utile spiegare come memorizzare file binari (come immagini, file compressi, ecc..) in un Database (MySql nel nostro caso), per poi recuperarli per vari scopi (ad esempio per scaricarli). 
Alcune nozioni prendono spunto dall'articolo di Florian Dittmer, pubblicato su phpbuilder.com, che comunque, stando alle varie discussioni sui forum, ha dato qualche problema nelle sue applicazioni pratiche.
Le ragioni per effettuare lo storage di un file in un DB anzichè in una directory, possono essere molteplici; una di queste è certamente la necessità di proteggere adeguatamente i files da visualizzazioni o download indesiderati o non autorizzati, risultato che si ottiene in modo più facile e, forse, più efficace con il metodo che si sta proponendo. Pensiamo infatti, riprendendo l'esempio di cui sopra, all'ipotesi in cui si volesse consentire soltanto ad utenti registrati la possibilità di scaricare dei files da una zona protetta; appare evidente che avere i files stessi all'interno del Database, assicurerebbe una protezione ed una efficacia maggiore rispetto all'alternativa di avere gli stessi in qualche directory sperduta all'interno del disco rigido.
Cercheremo quindi di costruire uno script che ci consenta di inserire il file desiderato nel db, tramite Upload con metodo POST (su cui vi rimando al mio articolo presente in questa sezione), e che successivamente ci permetta di scaricare il file stesso, magari dopo un'autenticazione, o di visualizzarlo. 
Creazione della tabella
Anzitutto dobbiamo realizzare Il Database e la relativa tabella destinata a contenere il file uploadato (lo faremo tramite script, ma naturalmente si può fare da linea di comando, o tramite tools quali phpMyAdmin). 
Ecco il codice PHP necessario per compiere queste operazioni (da copiare ed incollare in un file di testo da salvare come quello_che_vuoi.php):
<?php
// CONNESSIONE AL MYSQL
@mysql_connect("host", "user", "password") or die("Connessione fallita !");
// CREAZIONE DATABASE
@mysql_create_db("FileBinari") or die("Creazione Database fallita !");
// SELEZIONE DATABASE
@mysql_select_db("FileBinari") or die("Selezione Database fallita !");
// CREAZIONE TABELLA
@mysql_query("
CREATE TABLE file_binari (
Id int(4) NOT NULL auto_increment,
Descrizione varchar(255) NOT NULL default '',
DatiBinari mediumblob NOT NULL,
Nome varchar(50) NOT NULL default '',
Size int(10) NOT NULL default '0',
Type varchar(50) NOT NULL default '',
PRIMARY KEY (Id)
)
") or die("Creazione Tabella fallita !");
?>  
Il campo destinato ad accogliere i dati binari (DatiBinari) è di tipo mediumblob e può contenere fino a 1,6 Megabyte di dati (dovrebbe essere sufficiente, ma volendo si può optare per il tipo longblob, che può contenere fino a 4,2 Gigabyte di dati. Nel caso di file superiori ai due Mega, ci si dovrà preoccupare di cambiare il settaggio del parametro upload_max_filesize nel file php.ini, che di default è 2 Megabyte.Inseriamo il file
Una volta creati il Database e la tabella, possiamo occuparci della pagina che conterrà sia il modulo html, che ci consentirà di fare l'Upload del file, sia il codice PHP che processerà il contenuto del form e provvederà ad inserire il file uploadato nel DB (anche qui, copiare ed incollare in un file di testo da salvare come quello_che_vuoi.php):
<?php
if(!isset($_POST)) $_POST = $HTTP_POST_VARS;
$self = isset($_SERVER) ? $_SERVER["PHP_SELF"] : $HTTP_SERVER_VARS["PHP_SELF"];
if($_POST["invia"]) {
// CONNESSIONE AL MYSQL
@mysql_connect("host", "user", "password") or die("Connessione fallita !");
// SELEZIONE DATABASE
@mysql_select_db("FileBinari") or die("Selezione Database fallita !");
// MEMORIZZIAMO NELLA VARIABILE $data IL CONTENUTO DEL FILE
$data = addslashes(fread(fopen($_FILES["file_binario"]["tmp_name"], "rb"), $_FILES["file_binario"]["size"]));
// ESEGUIAMO LA QUERY DI INSERIMENTO
$result = @mysql_query("INSERT INTO file_binari (Descrizione, DatiBinari, Nome, Size, Type) 
VALUES ('" . $_POST["Descrizione"] . "','$data','" . $_FILES["file_binario"]["name"] . "', 
'" . $_FILES["file_binario"]["size"] . "','" . $_FILES["file_binario"]["type"] . "')") 
or die("Query di inserimento fallita !");
// ESITO POSITIVO
echo "Il file " . basename($_FILES["file_binario"]["name"]) . " è stato correttamente inserito nel Database.";
// CHIUDIAMO LA CONNESSIONE A MYSQL
@mysql_close();
} else {
echo "
<html>
<head>
<title>Form per l'inserimento</title>
</head>
<body>
<div align=\"center\">
<table>>
<form action=\"$self\" method=\"POST\" enctype=\"multipart/form-data\">
<tr>
<td valign=\"top\">Descrizione </td>
<td><textarea name=\"Descrizione\" cols=\"40\" rows=\"5\"></textarea></td>
</tr>
<tr>
<td>File</td>
<td><input type=\"file\" name=\"file_binario\" size=\"40\"></td>
</tr>>
<tr>
<td colspan=\"2\" valign=\"bottom\" align=\"center\" height=\"30\">
<input type=\"submit\" value=\"Invia il file\" name=\"invia\"></td>
</tr>
</form>
</table>
</div>
</body>
</html>
";
}
?>  
La parte che voglio rimarcare di questo codice (non mi soffermo sul modulo HTML, ovviamente, nè sull'inserimento vero e proprio nel Database su cui si possono guardare le guide presenti in questo sito), è la lettura e la "preparazione" del file all'inserimento. Questo avviene grazie alla funzione fread(), che salvaguarda la corrispondenza binaria, ed alla funzione addslashes(), che fa l'escape (aggiungendo un backslash) dei caratteri che potrebbero dare "fastidio" (apici singoli, apici doppi e lo stesso backslash).
Inseriamo qualche file di esempio nel Database (possibilmente di tipi diversi, magari qualche immagine e qualche altro tipo di file).Visualizzare o scaricare il file
A questo punto abbiamo bisogno del codice per visualizzare e/o scaricare questi files ma, siccome siamo dei bravi programmatori, prepareremo uno script che a seconda del tipo proponga o meno l'opzione "visualizza" oltre a "scarica". Ecco il possibile codice della pagina che visualizzerà i files con le opzioni(da copiare ed incollare in un file di testo da salvare come quello_che_vuoi.php):
<?php
// CONNESSIONE AL MYSQL
@mysql_connect("host", "user", "password") or die("Connessione fallita !");
// SELEZIONE DATABASE
@mysql_select_db("FileBinari") or die("Selezione Database fallita !");
// TIPI DI FILE VISUALIZZABILI
$visualizzabili = array("image/jpeg", "image/pjpeg", "image/gif", "image/png");
$query = "SELECT * FROM file_binari";
$select = @mysql_query($query) or die("Query fallita !");
echo "
<div align=\"center\"> <table>
";
while($result = @mysql_fetch_array($select)) {
echo " <tr>\n <td align=\"center\">" . $result["Nome"];
echo "<font size=\"1\">(" . $result["Size"] . " bytes)</font>";
if($result["Descrizione"]) echo "<br>" . $result["Descrizione"];
echo "</td>\n <td valign=\"top\">  <a href=\"actions.php?action=download";
echo "&Id=" . $result["Id"] . "\" target=\"_blank\">download</a>  </td>\n";
echo " <td valign=\"top\">";
if(in_array($result["Type"], $visualizzabili)) {
echo "  <a href=\"actions.php?action=view&Id=" . $result["Id"] . "\" ";
echo "target=\"_blank\">visualizza</a>  ";
}
echo "</td>\n </tr>\n";
}
echo "</table>\n</div>\n";
// CHIUDIAMO LA CONNESSIONE A MYSQL
@mysql_close();
?>  
Molto semplice: estraiamo tutto il contenuto del Database e lo visualizziamo, a seconda poi che il file sia o meno di un tipo compreso nell'array $visualizzabili (immagini .gif, .jpg e .png), viene o non viene proposta l'opzione "visualizza" (l'opzione download è comunque offerta).Problemi di Content-Type
Ed ecco il possibile codice della pagina actions.php che provvederà a visualizzare o a far scaricare il file (da copiare ed incollare in un file di testo da salvare come actions.php):
<?php
if(!isset($_GET)) $_GET = $HTTP_GET_VARS;
if($_GET["action"] && $_GET["Id"] && is_numeric($_GET["Id"])) {
// CONNESSIONE AL MYSQL
@mysql_connect("host", "user", "password") or die("Connessione fallita !");
// SELEZIONE DATABASE
@mysql_select_db("FileBinari") or die("Selezione Database fallita !");
switch($_GET["action"]) {
// VISUALIZZAZIONE
case "view" :
$query = "SELECT DatiBinari, Type FROM file_binari WHERE Id = '" . $_GET["Id"] . "'";
$select = @mysql_query($query) or die("Query fallita !");
$result = @mysql_fetch_array($select);
$data = $result["DatiBinari"];
$type = $result["Type"];
Header("Content-type: $type");
echo $data;
break;
// DOWNLOAD
case "download" :
$query = "SELECT DatiBinari, Nome, Type FROM file_binari WHERE Id = '" . $_GET["Id"] . "'";
$select = @mysql_query($query) or die("Query fallita !");
$result = @mysql_fetch_array($select);
$data = $result["DatiBinari"];
$name = $result["Nome"];
$type = $result["Type"];
// SE IL BROWSER E' INTERNET EXPLORER
if(ereg("MSIE ([0-9].[0-9]{1,2})", $_SERVER["HTTP_USER_AGENT"])) {
header("Content-Type: application/octetstream");
header("Content-Disposition: inline; filename=$name");
header("Expires: 0");
header("Cache-Control: must-revalidate, post-check=0, pre-check=0");
header("Pragma: public");
} else {
header("Content-Type: application/octet-stream");
header("Content-Disposition: attachment; filename=$name");
header("Expires: 0");
header("Pragma: no-cache");
}
echo $data;
break;
default :
// DEFAULT CASE, NESSUNA AZIONE
break;
} // endswitch
// CHIUDIAMO LA CONNESSIONE
@mysql_close();
} //endif
?>  
Come detto, la pagina chiamata actions.php visualizza o forza il download del file desiderato. A quest'ultimo proposito però vanno fatte alcune considerazioni in relazione al Content-Type octet-stream (o octetstream come preferisce, per oscure ragioni, Internet Explorer), che può essere considerato come il tipo "standard" per i file binari.
Octet Stream vuol dire, letteralmente, "flusso di ottetti", ossia flusso di numeri a otto bit.
Ebbene il problema sorge perchè si è lontani dall'affermarsi di uno standard in tema di Content-Type, per cui quando si inviano intestazioni di questo tipo, occorre porre attenzione ai vari browser che queste intestazioni possono ricevere; a questo proposito ecco i browser (su piattaforma Windows e Linux) su cui ho testato con successo questo script:
WINDOWS
Explorer 5.5
Mozilla 1.1
LINUX
Konqueror 2.2.1
Mozilla 1.1
Galeon 1.2.5
Netscape Communicator 4.78
I soli problemi riscontrati hanno riguardato il download dei file su OPERA (6.05 per Windows e 6.03 per Linux) il quale, nonostante il Content-Type octet-stream fosse perfettamente riconosciuto, se si trattava di un'immagine .xxx ignorava del tutto il Content-Type passato e si comportava come se questo fosse stato image/xxx, basandosi sul riconoscimento dell'estensione e questo nonostante la relativa opzione non fosse stata settata.Conclusioni
A conclusione di questo articolo, voglio segnalarvi anche un altro modo per visualizzare le immagini. Inserire il link alla pagina che abbiamo chiamato actions.php (passando nella query string anche l'ID e l'action uguale a view, naturalmente) all'interno del tag <img> (anche all'interno di una normale pagina .HTML). Per vedere quanto questo sia facile, provate a sostituire, all'interno del codice della pagina che ci offre l'opportunità di scaricare e/o visualizzare i files, il ciclo while ivi presente con questo:
while($result = @mysql_fetch_array($select)) {
if(in_array($result["Type"], $visualizzabili)) {
echo " <tr>\n <td align=\"center\"><img src=\"actions.php?action=view&Id=" . $result["Id"] . "\">";
echo "</td>\n </tr>\n";
}
}

Immagini all'interno di MySQL
Ho una pagina che prende tutti i dati, compresa la foto, e li inserisce in un db. La foto la metto in un campo MediumBlob 
tutto funziona, la foto viene caricata all'interno del db 
ora.....qual'è il metodo + pratiko e veloce per visualizzare queste immagini all'interno di una pagina, e non come qui ...dove devo cliccare per vedere la foto in una nuova pagina ? 

Ti spiego come faccio io, naturalmente dovrai adattare lo script alle tue esigenze. 
Ogni volta che c'è un immagine stampi una cosa del genere: 

code:
--------------------------------------------------------------------------------
<img src="thumb.php?blobId=<? echo $tuo_id?>"/>
--------------------------------------------------------------------------------
Il file che recupera l'immagine dal db e la mostrerà sarà appunto thumb.php 
code:
--------------------------------------------------------------------------------
<?
global $blobId;
include 'config.inc.php';
$db = mysql_connect($db_host, $db_user, $db_password)or die('1. '.mysql_error());
mysql_select_db($db_name, $db)or die ('2. '.mysql_error());
$dbQuery = "SELECT blob_type, blob_data FROM legenda WHERE id_legenda = $blobId";
$result = mysql_query($dbQuery) or die('3. '.mysql_error());
$fileType = @mysql_result($result, 0, "blob_type");
$fileContent = @mysql_result($result, 0, "blob_data");
header("Content-type: $fileType");
echo $fileContent;
?>
--------------------------------------------------------------------------------
dovrai modificare praticamente solo il nome dei campi che vai a recuperare ed alcune variabili, niente di più. 
funziona tutto alla grandissima 
prova ad usare l'array $_GET per richiamare la variabile global $blobId: 
code:--------------------------------------------------------------------------------
$_GET['blobId'];

Aggiornare un campo nel DataBase
Invece di utilizzare INSERT, basta usare la voce UPDATE
UPDATE campo = 'nuovo valore' WHERE campo = 'valore'
oppure
UPDATE tabella SET CAMPO='new_value' WHERE CAMPO='old_value'


Contare i campi in un DataBase

Ho in un database mySQL la tabella users, dove all'interno ci sono registrati gli utenti... Come posso estrarre l'ultimo ID inserito? (in modo di poter stampare a video il numero di utenti registrati?) 
Dentro la tabella users, ho un campo, dove viene segnato l'ultima data di accesso... come posso (per ogni campo) leggere la data (e ora) e calcolare se l'utente è ancora online e scrivere il numero di utenti attivi sul sito in quel momento? 
potete scrivermi un piccolo esempio? 
RISPOSTA ALLA DOMANDA 1: puoi utilizzare una query del tipo COUNT 
$query="SELECT COUNT(*) FROM nome_tabella"; 
ti darà come risultato il totale delle righe della tabella 
mentre se hai bisogno il conteggio di una particolare categoria di utenti puoi aggiungere il WHERE 
$query="SELECT COUNT(*) FROM nome_tabella WHERE nome_campo=condiz"; 

Proteggere una pagina con username e password
Con questo script php è possibile proteggere una pagina web, tramite username e password.
Lo script include un array che da la possibilità di impostare quattro username e altrettante password; è comunque possibile personalizzarlo ed aumentare il numero degli username disponibili.
Questo è il codice da utilizzare. E' sufficiente includerlo in una pagina con estensione .php
<?php
if(!isset($PHP_AUTH_USER))
{
Header("WWW-Authenticate: Basic realm=\"Xavier Protection\"");
Header("HTTP/1.0 401 Unauthorized");
echo "Text to send if user hits Cancel button\n";
exit;
}
else
{
$user_passwords = array (
"user1" => "password1",
"user2" => "password2",
"user3" => "password3",
"user4" => "password4"
);
if (($PHP_AUTH_USER == "") || ($PHP_AUTH_PW == ""))
{
Header("HTTP/1.0 401 Unauthorized");
echo "Sorry, could find your password!";
exit;
}
else if (strcmp($user_passwords[$PHP_AUTH_USER],$PHP_AUTH_PW) == 0)
{
echo "This is the password protected page.";
exit;
}
else
{
Header("HTTP/1.0 401 Unauthorized");
echo "Sorry, could find your password!";
exit;
}
}
?>
Come si può vedere analizzando il codice, la lista degli username e delle password viene gestita dall'array $user_passwords.
Per modificarli, basta cambiare le voci in grassetto; logicamente user1 corrisponderà a password1, user2 a password2, e così via.

Ritardare il caricamento di una pagina
In Php è possibile ritardare il caricamento di una pagina specificando con la funzione sleep() il numero di secondi e con la funzione usleep() il numero di millisecondi.
Un esempio: 
<?PHP
    sleep(10);
    echo "Ritardo di 10 secondi";
?>
Con i millisecondi: 
<?PHP
    usleep(100);
    echo "Ritardo di 100 millisecondi";
?>

Cancellare un record dalla pagina web
Abbiamo una tabella contente i seguenti campi (id, titolo, data luogo). I dati escono tutti uno sotto l'altro in una pagina web. Ora vorrei fare che ne seleziono uno e che posso modificarlo o cancellarlo. Come faccio?
Potresti inserire per ogni record due link modifica ed elimina. Ogni link punta ad una pagina che svolge il compito e riceve via get l'id su cui lavorare record con id inserito nella variabile $id
esempio
<a href="modifica_record.php?id=$id">modifica</a>
<a href="elimina_record.php?id=$id">elimina</a>
e in entrambi le pagine ti aspetti $_GET["id"]
che puoi usare per estrarre i dati dal record per modificarli oppure per cancellarli

INDEX.PHP
code:--------------------------------------------------------------------------------
<?
mysql_connect('localhost', 'root'); //si connette a mysql
mysql_select_db('donne'); //selezioni il database interessato
$result = mysql_query("SHOW TABLES"); // Mostra le tabelle
while($array = mysql_fetch_array($result))
/* Finchè la condizione si può verificare, l'attuale condizione è quella di stampare la singola tabella */
{
/* Stampa a video la tabella ed i link necessari per la modifica o la cancellazione */
print "<table><tr>
<td>$array[0]</td>
<td><a href=\"./go.php?action=del&table='$array[0]'\"></td>
<td><a href=\"./go.php?action=mod&table='$array[0]'\"></td>
</tr></table>";
}
mysql_close();
?>
--------------------------------------------------------------------------------

GO.PHP
code:--------------------------------------------------------------------------------
<?
switch($_GET['action']) /* 'Controlla' la variabile action data col metodo get */
{
case "del": /* Se il contenuto è 'del' e quindi indica la cancellazione */
mysql_query("DROP TABLE $_GET[table]") or die("Impossibile cancellare la tabella $_GET[table], Messaggio di MySQL:<br>" . mysql_error());
/* Cancella la tabella oppure stampa a video un messaggio di errore */
break; /* Fine istruzione */
case "mod": /* Se il contenuto è 'mod' e quindi indica la modifica */

/* Esecuzione query di modifica */
break; /* Fine istruzione */
}
?>
--------------------------------------------------------------------------------
Lo script che ti ho postato è un pò rudimentale e non sicuro, quindi è utile solo in caso di uso strettamente personale...
Inoltre... cosa intendi per modifica??
nella forma avrai checkbox, options varie, etc., avrai fatto un loop tra i risultati mysql per metterli nella pagina, lo stesso indice lo puoi usare per le label che li contengono ad esempio e che passerai con il submit su "MODIFICA" o "CANCELLA",ecc., solo se la checkbox è selezionata

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).

Upload di file in Php
Il Php mette a disposizione la funzione move_uploaded_file() per eseguire il trasferimento di un file sul server. Detta funzione accetta tre parametri obbligatori, ovvero il percorso del file sul client che lo invia, il percorso della directory remota in cui caricare il file ed il nome con cui dovrà essere caricato il file, che per default è il nome originario del file sul client. (scarica qui)
Si crei il file upload.html e vi si inserisca un modulo Html:
<html>
<body>
<form method="post" action="upload.php" enctype="multipart/form-data">
<input type="file" name="miofile">
<input type="submit" value="Upload">
</form>
</body>
</html>

Di seguito il codice commentato del file upload.php
<?PHP
// RECUPERO I PARAMETRI DA PASSARE ALLA FUNZIONE PREDEFINITA PER L'UPLOAD
$cartella = 'upload/';
$percorso = $_FILES['miofile']['tmp_name'];
$nome = $_FILES['miofile']['name'];
// ESEGUO L'UPLOAD CONTROLLANDO L'ESITO
if (move_uploaded_file($percorso, $cartella . $nome))
{
print "Upload eseguito con successo";
}
else
{
print "Si sono verificati dei problemi durante l'Upload";
}
?>

Oltre alla funzione move_uploaded_file() vediamo che il codice del file upload.php viene aperto con un riferimento all'oggetto $_FILE[][] che lavora come variabile d'ambiente nel recupero di informazioni sul file specificato come primo parametro; il secondo parametro è rappresentato dalla collezione a cui fa riferimento $_FILE[][] nel recupero delle informazioni. E' possibile sfruttare questo oggetto per eseguire controlli, ad esempio, sul tipo di file e sulle sue dimensioni, per ottenere Upload controllati e coerenti a seconda delle esigenze dell'amministratore del sito, ad esempio solo immagini in un certo formato, file di testo, ecc...
Per ottenere queste informazioni è possibile utilizzare le collezioni
$_FILES['miofile']['type']
$_FILES['miofile']['size']
Il valore di size è espresso in byte.

===================================
2 - Altro upload in php
Il Form
Per prima cosa dovete creare un form per selezionare il file che volete uploadare:
form.php
<form action="upload.php" method="post" ENCTYPE="multipart/form−data">
File: <input type="file" name="file" size="30"> <input type="submit" value="Upload!">
</form>
Una cosa che molte persone dimenticano è questa: ENCTYPE="multipart/form−data".
Se questo non viene scritto, lo script non funziona
Parte di codice per l'upload
Ora abbiamo bisogno dello script per l'upload dei files:
upload.php
<?php
// ==============
// Configurazione
// ==============
$uploaddir = "uploads"; // Ossia dove volete che i files vengano uploadati. Importante
// assicurarsi che la cartella abbia i permessi impostati a 777
// ==============
// Parte Upload
// ==============
if(is_uploaded_file($_FILES['file']['tmp_name']))
{
move_uploaded_file($_FILES['file']['tmp_name'],$uploaddir.'/'.$_FILES['file']['name']);
}
print "Il file è stato uploadato correttamente";
?>

Qualcosa di Avanzato...
Si può scegliere quali sono le estensioni ammesse o la grandezza massima, le dimensioni di altezza e larghezza.
Per fare ciò, prima di tutto bisogna aggiungere qualche cosa alla configurazione:
<?php
// ==============
// Configuration
// ==============
$uploaddir = "uploads"; // dove vuoi che i file vengano caricati. Importante: i permessi della cartella devono essere 777
$allowed_ext = "jpg, gif, png, pdf"; // Queste sono le estensioni che sono ammesse
$max_size = "50000"; // 50000 è lo stesso di 50kb
$max_height = "100"; // Questi sono pixels
$max_width = "100"; // Questi sono pixels
?>
E poi aggiungiamo il codice sotto la configurazione:
<?php
// Controllo dell'estensione
$extension = pathinfo($_FILES['file']['name']);
$extension = $extension[extension];
$allowed_paths = explode(", ", $allowed_ext);
for($i = 0; $i < count($allowed_paths); $i++) {
if ($allowed_paths[$i] == "$extension") {
$ok = "1";
}
}
// Controllo delle dimensioni del file
if ($ok == "1") {
if($_FILES['file']['size'] > $max_size)
{
print "Il file è troppo grande";
exit;
}
// Controllo delle dimensioni di altezza e larghezza
list($width, $height, $type, $w) = getimagesize($_FILES['file']['tmp_name']);
if($width > $max_width || $height > $max_height)
{
print "L'altezza o la larghezza dell'immagine è troppo grossa!";
exit;
}
?>

Qui l'intero codice

form.php
<form action="upload.php" method="post" ENCTYPE="multipart/form-data">
File: <input type="file" name="file" size="30"> <input type="submit" value="Upload!">
</form>

upload.php

<?php
// ==============
// Configuration
// ==============
$uploaddir = "uploads";
$allowed_ext = "jpg, gif, png, pdf";
$max_size = "50000";
$max_height = "100";
$max_width = "100";
// Controllo delle Estensioni
$extension = pathinfo($_FILES['file']['name']);
$extension = $extension[extension];
$allowed_paths = explode(", ", $allowed_ext);
for($i = 0; $i < count($allowed_paths); $i++) {
if ($allowed_paths[$i] == "$extension") {
$ok = "1";
}
}
// Controllo dimensione del File
if ($ok == "1") {
if($_FILES['file']['size'] > $max_size)
{
print "Il file è troppo grande!";
exit;
}
// Check Height & Width
if ($max_width && $max_height) {
list($width, $height, $type, $w) = getimagesize($_FILES['file']['tmp_name']);
if($width > $max_width || $height > $max_height)
{
print "L'altezza o la larghezza dell'immagine è troppo grossa!";
exit;
}
}
// Parte dell'upload
if(is_uploaded_file($_FILES['file']['tmp_name']))
{
move_uploaded_file($_FILES['file']['tmp_name'],$uploaddir.'/'.$_FILES['file']['name']);
}
print "Il file è stato uploadato correttamente";
} else {
print "Errore! Estensione non corretta!";
}
?>

===============================
3 - Gestire gli Upload tramite Form
Per prima cosa vediamo la pagina Html con il Form:
<html>
<head>
<title>Upload</title>
</head>
<body>
<form enctype="multipart/form-data" action="upload.php" method="POST">
<input type="hidden" name="MAX_FILE_SIZE" value="30000">
Invia questo file: <input name="userfile" type="file">
<input type="submit" value="Invia File">
</form>
</body>
</html>
Sul form qui sopra non credo ci sia molto da dire; l'unica nota consiste nel campo nascosto MAX_FILE_SIZE il quale deve precedere il campo di immissione del file e il suo valore è la dimensione massima accettata del file. Il valore è in byte.
Prima di vedere il codice dello script vorre ricordarvi che PHP è dotato della variabile globale $_FILES contenente tutte le informazioni sul file caricato.
Facciamo un paio di esempi per capire come funziona la variabile $_FILES:
Per vedere il nome del file useremo:
$_FILES['userfile']['name']
Per vedere il mime-type:
$_FILES['userfile']['type']
Per vedere le sue dimensioni:
$_FILES['userfile']['size']
ecc.
Vediamo ora lo script "upload.php" che reuperà il file e lo mette nella cartella che noi abbiamo predisposto per i file uploadati:
<?
//percorso della cartella dove mettere i file caricati
$uploaddir = '/var/www/myupload/';
//Recupero il percorso temporaneo del file
$userfile_tmp = $_FILES['userfile']['tmp_name'];
//recupero il nome originale del file caricato
$userfile_name = $_FILES['userfile']['name'];
print "<pre>";
//copio il file dalla locazione temporanea alla mia cartella upload
if (move_uploaded_file($userfile_tmp, $uploaddir . $userfile_name))
{
//Se l'operazione è andata a buon fine...
print "File inviato con successo. Ecco alcune informazioni:\n";
print_r($_FILES);
}
else
{
//Se l'operazione è fallta...
print "Upload NON valido! Alcune informazioni:\n";
print_r($_FILES);
}
print "</pre>";
?>
L'unica nota riguarda la funzione move_uploaded_file la quale verifica se il file è stato caricato correttamente oppure no: nel primo caso la funzione restituisce TRUE e contemporaneamente sposta il file dalla sua locazione temporanea alla directory "definitiva"; in caso contrario restituisce FALSE e non compie alcuna operazione.
Nota n.1
Nelle versioni di PHP precedenti alla 4.1.0 si deve utilizzare $HTTP_POST_FILES anzichè $_FILES.
Nelle versioni di PHP precedenti alla 4.0.3, si utilizzi copy() e is_uploaded_file() anzichè move_uploaded_file
Nota n.2
I file sono, di default, salvati in una directory temporanea sul server, a meno che un diverso percorso sia specificato nella direttiva upload_tmp_dir nel file php.ini. La directory del server predefinita può essere cambiata impostando la variabile di ambiente TMPDIR in cui è in esecuzione PHP.

===============================
4 - Upload di file in Php
Il Php mette a disposizione la funzione move_uploaded_file() per eseguire il trasferimento di un file sul server. Detta funzione accetta tre parametri obbligatori, ovvero il percorso del file sul client che lo invia, il percorso della directory remota in cui caricare il file ed il nome con cui dovrà essere caricato il file, che per default è il nome originario del file sul client.
Si crei il file upload.html e vi si inserisca un modulo Html:
<html>
<body>
<form method="post" action="upload.php" enctype="multipart/form-data">
<input type="file" name="miofile">
<input type="submit" value="Upload">
</form>
</body>
</html>
Di seguito il codice commentato del file upload.php
<?PHP
// RECUPERO I PARAMETRI DA PASSARE ALLA FUNZIONE PREDEFINITA PER L'UPLOAD
$cartella = 'upload/';
$percorso = $_FILES['miofile']['tmp_name'];
$nome = $_FILES['miofile']['name'];
// ESEGUO L'UPLOAD CONTROLLANDO L'ESITO
if (move_uploaded_file($percorso, $cartella . $nome))
{
print "Upload eseguito con successo";
}
else
{
print "Si sono verificati dei problemi durante l'Upload";
}
?>
Oltre alla funzione move_uploaded_file() vediamo che il codice del file upload.php viene aperto con un riferimento all'oggetto $_FILE[][] che lavora come variabile d'ambiente nel recupero di informazioni sul file specificato come primo parametro; il secondo parametro è rappresentato dalla collezione a cui fa riferimento $_FILE[][] nel recupero delle informazioni. E' possibile sfruttare questo oggetto per eseguire controlli, ad esempio, sul tipo di file e sulle sue dimensioni, per ottenere Upload controllati e coerenti a seconda delle esigenze dell'amministratore del sito, ad esempio solo immagini in un certo formato, file di testo, ecc...
Per ottenere queste informazioni è possibile utilizzare le collezioni
$_FILES['miofile']['type']
$_FILES['miofile']['size']
Il valore di size è espresso in byte.

===============================
5 - Another way to Upload
Uploads up to 5 files user PHP, works perfectly on win32 servers such as IIS or Apache for windows. Demonstrates the use of copy(), functions, and switch operators.
<?
function uploadProg($filename1,$filename1_name,$filename2,$filename2_name,$filename3,$filename3_name,$filename4,$filename4_name,$filename5,$filename5_name){
########Set the destination here##############
$destination="C:\\Uploads\\";
copy($filename1,$destination."/".$filename1_name);
copy($filename2,$destination."/".$filename2_name);
copy($filename3,$destination."/".$filename3_name);
copy($filename4,$destination."/".$filename4_name);
copy($filename5,$destination."/".$filename5_name);
echo "<h1>File(s) Uploaded...</h1>";
echo "<b>$filename1_name was uploaded succesfully.</b><br>";
echo "<b>$filename2_name was uploaded succesfully.</b><br>";
echo "<b>$filename3_name was uploaded succesfully.</b><br>";
echo "<b>$filename4_name was uploaded succesfully.</b><br>";
echo "<b>$filename5_name was uploaded succesfully.</b><br><br>";
echo "<a href=\"upload.php\">Click here to go back.</a>";
}
function main(){?>

FORM PER L'UPLOAD

<form method="post" action="upload.php" enctype="multipart/form-data">
Files to Upload:<br>
<input type="file" name="filename1" size="20" tabindex="1"><br>
<input type="file" name="filename2" size="20" tabindex="2"><br>
<input type="file" name="filename3" size="20" tabindex="3"><br>
<input type="file" name="filename4" size="20" tabindex="4"><br>
<input type="file" name="filename5" size="20" tabindex="5"><br>
<input type="hidden" name="action" value="uploadProg">
<input type="submit" value="Upload Files" tabindex="6">
</form><?}
switch ($action){
default:
main();
break;
case "uploadProg":
if ($filename1=="none") {echo("<h1>No File Selected....</h1>"); break;} uploadProg($filename1,$filename1_name,$filename2,$filename2_name,$filename3,$filename3_name,$filename4,$filename4_name,$filename5,$filename5_name);
break;
}
?>
===============================
6 - Upload con limitazione di dimensioni e estensione

===============================
7 - 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)

Un contatore di accessi con file di testo
Abbiamo già visto come fare in Asp, grazie all'oggetto FileSystemObject, come implementare un contatore di accessi e scrivere il risultato su un file di testo (Rif. Un contatore di accessi con file di testo).

Il Php utilizza un metodo molto più semplice, per giunta nativo del linguaggio stesso, grazie alle funzioni fopen, fputs ed fclose, che rispettivamente aprono uno stream verso un file, inseriscono dei dati e chiudono lo stream.

Creiamo quindi un file di testo e scriviamoci il valore numerico zero (0), chiamiamolo contatore.txt e disponiamolo nella stessa directory in cui creeremmo il nostro file contatore.php.
Ecco il codice:
<?php
$file = ("contatore.txt");
$visite = file($file);
$visite[0]++;
$fp = fopen($file , "w");
fputs($fp , "$visite[0]");
fclose($fp);
echo $visite[0];
?>
Lanciamo ora nel server Web il file Php appena creato: potremo notare, aggiornando la pagina, che il valore numerico aumenterà di una unità.

Spedire email con il Php
Inviare email con Php è un'operazione alquanto semplice, grazie all'utilizzo della funzione mail() che, una volta richiamata all'interno della nostra applicazione, contatterà il sistema postale del nostro server (SendMail o server SMTP).
Nel caso in cui il nostro server non sia attrezzato, o per una momentanea disfunzione, l'operazione non potrà riuscire.
Questa la sintassi:
mail(destinatario, oggetto, messaggio, headers);
Ecco un picolo esempio di codice per l'invio di una mail:
<?PHP
// Specifica la tua mail e quella del destinatario
$mail_mittente = "mittente@sito.com";
$mail_destinatario = "destinatario@sito.com";

// Specifica l'oggetto ed il corpo della mail
$mail_oggetto = "Messaggio di prova";
$mail_corpo = "Questo è un messaggio di prova per testare la mia applicazione";

// Invia la mail e lancia un messaggio di conferma
if (mail($mail_destinatario, $mail_oggetto, $mail_corpo, "From: $mail_mittente"))
{
echo "Messaggio inviato con successo a $mail_destinatario";
}
// oppure un messaggio di errore in caso di fallimento
else
{
echo "Errore. Nessun messaggio inviato.";
}
?>

Ovviamente è possibile personalizzare detto codice nel modo più opportuno. Con qualche piccolo accorgimento, e con l'aiuto dei form, potrete creare facilmente applicazioni molto interessanti come, ad esempio, un applicazione per raccogliere i suggerimenti degli utenti oppure per inviare cartoline virtuali.
============================
Funzione Mail 
<? 
/* 
Funzione per spedire email testuali, in formato HTML o testuali con allegato 
Parametri: 
- "tipo" (testo, html, allegato); 
- "mittente" indirizzo email del mittente; 
- "destinatario" indirizzo email del destinatario; 
- "oggetto" oggetto della mail 
- "body" corpo della mail, in formato testo se scegliamo di spedire la mail in formato testo o con allegato, file HTML se dobbiamo 
spedire una pagina HTML 
- "nome_file" il nome del file, con tanto di percorso, del file che vogliamo allegare alla mail 
- "file_conferma" nome del file che deve visualizzare la funzione dopo aver spedito correttamente la mail 
*/ 
function sendmail ($tipo, $mittente, $destinatario, $oggetto, $body, $nome_file, $file_conferma) { 
// definizione messaggi di errore 
$errore_formato_indirizzo_mail = "Inserisci un indirizzo E-Mail, del mittente o del destinatario, corretto."; 
$errore_tipo = "Scegli il tipo di mail da inviare (testo / HTML)."; 
$errore_oggetto = "Inserisci l'ogetto della mail."; 
$errore_body = "Inserisci il testo della mail."; 
$errore_nome_file = "Inserisci il nome del file da allegare."; 
$errore_conferma = "Indica il file da visualizzare come conferma invio mail."; 
$errore_spedizione = "Inpossibile inviare l'email."; 
// controllo parametri della funzione e restituzione degli errori 
if (!$tipo) { return $errore_tipo; } 
if (!$oggetto) { return $errore_oggetto; } 
if (!$body) { return $errore_body; } 
if ($tipo == "allegato" and !$nome_file) { return $errore_nome_file; } 
if (!$file_conferma) { return $errore_conferma; } 
// controllo caratteri che deve contenere l'indirizzo email del mittente 
$mail_mittente = eregi("^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*(\.[a-z]{2,3})$", $mittente); 
$mail_destinatario = eregi("^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*(\.[a-z]{2,3})$", $destinatario); 
// se l'email è nel giusto formato (xxxx@xxx.xxx) spedisci email 
if ($mail_mittente != false and $mail_destinatario != false) { 
//definizione degli headers 
$uid = strtoupper(md5(uniqid(time()))); 
$headers = "From: $mittente\r\n"; 
$headers .= "MIME-Version: 1.0\r\n"; 
$boundary = uniqid($uid); 
// controllo del tipo di email (testo, HTML) da spedire 
switch ($tipo) { 
case 'testo': 
// definizione email di testo 
$spedizione = mail($destinatario, $oggetto, $body, 
"From: $mittente\nReply-To: $mittente\nX-Mailer: PHP/" . phpversion()); 
break; 
case 'html': 
// definizione email HTML 
$headers .= "From: $mittente <$mittente>\n". 
"MIME-Version: 1.0\n". 
"Content-Type: multipart/mixed; boundary=$uid\n\n". 
"--$uid\n". 
"--$uid\n". 
"Content-Type: text/html;\n". 
"Content-Transfer-Encoding: 7bit\n\n"; 
$spedizione = mail($destinatario, $oggetto, $body, $headers ); 
break; 
case 'allegato': 
// definizione email con allegato 
$mime_boundary = "==Multipart_Boundary_x{$uid}x"; 
$headers .= "Content-Type: multipart/mixed;\n" . 
" boundary=\"{$mime_boundary}\""; 
$email_message .= "--{$mime_boundary}\n" . 
"Content-Type:text/plain; charset=\"iso-8859-1\"\n" . 
"Content-Transfer-Encoding: 7bit\n\n" . 
$email_message .= $body . "\n\n"; 
// lettura file da allegare 
$file = fopen($nome_file,'rb'); 
$data = fread($file,filesize($nome_file)); 
fclose($file); 
// encoding base64 
$data = chunk_split(base64_encode($data)); 
$email_message .= "--{$mime_boundary}\n" . 
"Content-Type: application/octet-stream;\n" . 
" name=\"{$nome_file}\"\n" . 
"Content-Transfer-Encoding: base64\n\n" . 
$data . "\n\n" . 
"--{$mime_boundary}--\n"; 
$spedizione = mail($destinatario, $oggetto, $email_message, $headers); 
break; 

if($spedizione) { 
// visualizzazione messaggio di conferma spedizione 
require($file_conferma); 
} else { 
// visualizzazione messaggio d'errore spedizione 
return $errore_spedizione; 

} else { 
// altrimenti restituisci il messaggio di errore 
return $errore_formato_indirizzo_mail; 


?>

===============================================================
<?
// Codice di *esempio* per la spedizione di mail
// Queste variabili possono
// provenire anche da una form Web!
$to = "to_email_address";
$subject = "subject_email";
$message = "email_message";
// Funzione mail!
mail ($to, $subject, $message);
?>
Questo è il semplice codice di esempio per spedire una mail tramite PHP. E' importante notare che il file php.ini deve essere settato correttamente per operare in questo modo!!
.
================================================================
Impostare php.ini per funzione mail 
L'oggetto è già di per se chiaro: dal manuale ufficiale di php leggo che bisogna impostare due parametri nel file php.ini, quello relativo al server smtp e quello relativo al mittente, cioè sendmailfrom. ho scritto un codice che invia email in automatico a un indirizzo dato, la spedizione non va a buon fine, mi viene fuori questo messaggio: 
Warning: Failed to connect to mailserver, verify your "SMTP" setting in php.in 
Volevo sapere cosa devo impostare nel parametro del server, soprattutto dove vado a cercarl
ini_set("SMTP","mail.***.***"); 
//metti come secondo parametro l'indirizzo del server SMTP 
ini_set("smtp_port","25"); 
//metti come secondo parametro il la porta del server SMTP 
ini_set("sendmail_from","mittente@mail.***"); 
//metti come secondo parametro l'indirizzo e-mail del mittente 
Non ci siamo capiti, io voglio sapere quale smtp devo impostare? quello che uso nell'account della mia posta elettronica?
certo come server smtp metti quello della tua posta elettronica es.: mail.libero.it, mentre come "sendmail_from" metti il tuo indirizzo di posta elettronica "*****@libero.it".
ho fatto così ma mi dà errore lo stesso
Rettifico, bastava riavviare windows, che pigrizia
Io sto in locale. Che devo fare? 
Qual è l'indirizzo del server smtp? E la porta?
Abbiate pazienza: ho configurato php.ini in maniera corretta: 
------------------------------------------------- 
[mail function] 
; For Win32 only. 
SMTP = mail.libero.it 
smtp_port = 25 

; For Win32 only. 
sendmail_from = MIOUSER@tiscali.it 
-------------------------------------------------- 
Il mio provider è libero. 
Sono in locale. 
La funzione che uso è questa: 
--------------------------------------------------- 
function email(){ 
// Configuro i dati di invio della mail 
// (destinatario, mittente, oggetto e corpo) 
$mail_to = "SUOUSER@CHENESO.IT"; 
$mail_subject = "tatata"; 
$mail_body = tatata"; 

// Specifico le intestazioni per il formato 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: MIOUSER@tiscali.it"; 
return (mail($mail_to, $mail_subject, $mail_body, $mail_in_html)); 

--------------------------------------------------- 


L'errore che mi dà è sempre, maledettamente, questo: 
---------------------------------------------------- 
Warning: mail() [function.mail]: Failed to connect to mailserver at "mail.libero.it" port 25, verify your "SMTP" and "smtp_port" setting in php.ini or use ini_set() in C:\Programmi\Apache Group\Apache2\htdocs\coopdoc\controllapa
rtecipante.php on line 225 
---------------------------------------------------- 
Io l'ho fatto 1 ora fa e funziona.... 
questa è la mia configurazione: 
[mail function] 
; For Win32 only. 
;SMTP = localhost 
SMTP = mail.libero.it 
; For Win32 only. 
sendmail_from = me@localhost.com 
; For Unix only. You may supply arguments as well (default: "sendmail -t -i"). 
;sendmail_path =
è il server mail di libero che oggi fa schifo...arriva dopo, fidati... 

Connessione ad un database mySql con Php
Come tutti i linguaggi lato server, anche con il Php è possibile connettersi ad un database. Il DBMS "favorito" per questo linguaggio è mySql: vediamo quindi come fare a connettersi tramite Php ad un database mySql.
Useremo 3 pagine: config.php, function.php e view.php.
Iniziamo a creare il file di configurazione (config.php):
<?PHP
$server = "";
$user = "";
$pwd = "";
$nome_db = "";
$query;
?>

Analizziamo adesso la funzione che permette di connettersi e di estrarre i dati dal database (function.php):
<?PHP
function db_connect($sql)
{
global $server;
global $user;
global $pwd;
global $nome_db;
global $query;
// Creiamo la stringa di connessione:
mysql_connect($server,$user,$pwd);
// Selezioniamo il database da utilizzare:
mysql_select_db($nome_db);
// Eseguiamo la query sql:
$query = mysql_query($sql);
}
?>

Infine vediamo come estrarre i dati dal nostro database (view.php):
<?PHP
require("config.php");
require("function.php");
db_connect("SELECT * FROM nome_tabella");
// Cicliamo su tutti i record del database
while($result = mysql_fetch_array($query))
{
echo $result["nome_tabella"] . "<br>";
}
mysql_close();
?>

Un semplice sistema di rotazione banner con PHP e Javascript
In questo tutorial vedremo come realizzare un rudimentale ad rotator (sistema di rotazione banner) usando poche righe di PHP. Nel nostro esempio imposteremo 4 differenti banner e relativi link, ma ovviamente potete impostarne quanti ne volete apportando semplici modifiche al codice.
Il codice, come vedrete, è davero molto semplice; l'unica nota di rilevo consiste nel fatto che per la visualizzazione del banner abbiamo scelto di usare Javascript in modo da consentirvi di usare questo script anche su un server diverso da quello sul quale verrà caricato il file, richiamando il nostro ad rotator anche su pagine Html.

Vediamo il codice:
<?
#Uso rand impostando come limiti 1 e 4
$spot = rand(1,4);

<#Creo uno switch impostando $spot come condizione
#Ovviamente creo 4 case...
switch($spot)
{

#Se $spot è uguale a 1...
case "1":
$pic = "banner-1.gif";
$link = "http://www.mrwebmaster.it";
break;

#Se $spot è uguale a 2...
case "2":
$pic = "banner-2.gif";
$link = "http://www.bannergratis.it";
break;

#Se $spot è uguale a 3...
case "3":
$pic = "banner-3.gif";
$link = "http://www.mrw.it";
break;

#Se $spot è uguale a 4...
case "4":
$pic = "banner-4.gif";
$link = "http://www.wmstats.it";
break;

}

#Uso print per stampare un po' di codice Javascript
#che serve per l'invocazione del banner scelto randomicamente
print "document.write('<center>')
document.write('<a href=\"" . $link . "\" target=\"_new\">')
document.write('<img border=\"0\" src=\"" . $pic . "\"></a>')
document.write('</center>')";
?>

Salviamo il file come banner.php e carichiamolo sul nostro server.
Come avrete notato il cuore del nostro piccolo ad rotator stà tutto nella combinazione della funzione rand (che usiamo per effettuare una scelta randomica del banner tra quelli disponibili) con un'istruzione condizionale switch (che ci serve per individuare il banner ed il relativo link da visualizzare).
Per visualizzare il banner sul nostro sito non ci resta che inserire nelle nostre pagine questa semplice inclusione Javascript:
<script src="http://www.tuosito.ext/banner.php"></script>

Un circuito di rotazione banner in Php
La funzione rand() di Php, combinata all'utilizzo degli array, permette in maniera semplice e veloce di creare un circuito di rotazione banner che mostra sulla pagina un banner a caso preso dall'elenco dell'array.

Si crei il file banner.php che conterrà il la funzione per la rotazione del banner; di seguito il codice corredato di opportuni commenti:
<?PHP
// CREO LA FUNZIONE DA RICHIAMARE SULLE PAGINE PHP
function MioBanner()
{
// CREO L'ARRAY CHE CONTIENE I BANNER
$banner[] = "lukeonweb.gif";
$banner[] = "mrwebmaster.gif";

// CREO L'ARRAY CHE CONTIENE LE URL ASSOCIATE AI BANNER
$url[] = "http://www.lukeonweb.net";
$url[] = "http://www.mrwebmaster.it";

// EFFETTUO LA SCELTA CASUALE DEL BANNER
$totale = count($banner) - 1;
$casuale = rand(0, $totale);

// STAMPO IL BANNER A VIDEO COL RELATIVO LINK ASSOCIATO
print "<a href='" . $url[$casuale] . "' target='_blank'><img src='" . $banner[$casuale] . "' border='0'></a>";
}
?>

Richiamiamo poi nel seguente modo la funzione MioBanner() in tutte le pagine che ci interessano, includendo il file banner.php nelle pagine:
<?PHP
require("banner.php");
?>
<html>
<body>

<p align="center">
<?PHP
MioBanner()
?>
</p>

</body>
</html>

Redirect in Php
Per effettuare il redirect in Php è sufficiente utilizzare il comando
<?PHP
header("location: http://www.sito.it/pagina.php");
?>
E' importante sottolineare il fatto che debba trattare di un URL assoluto e non solo il nome di un documento (anche se sullo stesso server).

Recupero dei dati da un modulo
Il Php lavora spesso e voluntieri con i moduli Html; per questo motivo è molto importante vedere come recuperare i valori immessi dai visitatori nei form loro priposti.
Credo sia ben noto al lettore che i form Html possono inviare i dati con due metodi: il get (che genera una QueryString ed accoda i dati all'indirizzo fisico della pagina) ed il post (invio classico).

Si prenda come riferimento il seguente modulo:
<form method="post" action="form.php">
<input type="text" name="nome_campo">
<input type="submit" value="vai">
</form>

Vediamo un esempio di come recuperare i dati nel caso di un invio classico da un form col metodo post, al file form.php:
<?PHP
echo $HTTP_POST_VARS["nome_campo"];
?>

Se il form fosse stato inviato col metodo get, invece, avremo utilizzato il seguente comando:
<?PHP
echo $HTTP_GET_VARS["nome_campo"];
?>

Amministrazione degli utenti con MYSQL
Vi siete mai domandati come si possono mettere i permessi sull'utente che ha l'accesso alle tabelle di mysql??
ok se ve lo siete domandato.. ho scritto questa pillola solo per voi..
Mi scuso fin d'ora se alcune parti risultano confuse e/o ci siamo orrori di ortografia
Allora cominciamo..
Tante volte ci preoccupiamo della sicurezza sulle nostre pagine PHP, magari facendo un accesso in lettura e scrittura da root
con tutti i permessi attivi.
Sappiamo tutti che mySQL installa un database chiamato mysql dove contiene diverse informazioni..
digitiamo dal prompt di DOS o dalla shell di linux
non preoccupatevi per root@ramengo:~# è il nome della mia macchina
code:--------------------------------------------------------------------------------
root@ramengo:~# mysql
mysql> use mysql
mysql> show tables;
--------------------------------------------------------------------------------
a video vi compariranno le tabelle del mysql.. embè bella scorperta direte..
allora
code:--------------------------------------------------------------------------------
+-----------------+
| Tables in mysql |
+-----------------+
| columns_priv |
| db |
| func |
| host |
| tables_priv |
| user |
+-----------------+
--------------------------------------------------------------------------------
Tutte queste tabelle servono per gestire gli accessi al server di mysql.
Attraverso queste tabelle, potete consentire accessi ad interi database oppure a ad alcune colonne
all'interno del database.
Potete settare i privilegi per ogni utente di lettura, scrittura cancellazione del Db etc...
Tutti i diritti assegnati vengono conferiti in modo gerarchico.
I diritti per esempio assegnati nella tabella USER sono universali, cioè se l'utente "tocio" ha privilegi che gli consentono di fare l'eliminazione di un DB (Drop)
l'utente potrà eliminare qualsiasi tabella contenuta in mysql.
Nella tabella DB potrete concedere privilegi relativi a database specifici oppure per più database
Nella tabella TABLES_PRIV potrete concedere privilegi relativi a una tabella oppure per un insieme di tabelle
Nella tabella COLUMNS_PRIV potrete concedere diritti su specifiche colonne se non dovete concedere diritti controllate che i diritti siano assegnati nella columns_priv
Vediamo ora in dettaglio le singole tabelle:
Tabella USER
code:--------------------------------------------------------------------------------
> show columns from user;
+-----------------------+-----------------------------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+-----------------------+-----------------------------------+------+-----+---------+-------+
| Host | varchar(60) binary | | PRI | | |
| User | varchar(16) binary | | PRI | | |
| password | varchar(16) | | | | |
| Select_priv | enum('N','Y') | | | N | |
| Insert_priv | enum('N','Y') | | | N | |
| Update_priv | enum('N','Y') | | | N | |
| Delete_priv | enum('N','Y') | | | N | |
| Create_priv | enum('N','Y') | | | N | |
| Drop_priv | enum('N','Y') | | | N | |
| Reload_priv | enum('N','Y') | | | N | |
| Shutdown_priv | enum('N','Y') | | | N | |
| Process_priv | enum('N','Y') | | | N | |
| File_priv | enum('N','Y') | | | N | |
| Grant_priv | enum('N','Y') | | | N | |
| References_priv | enum('N','Y') | | | N | |
| Index_priv | enum('N','Y') | | | N | |
| Alter_priv | enum('N','Y') | | | N | |
| Show_db_priv | enum('N','Y') | | | N | |
| Super_priv | enum('N','Y') | | | N | |
| Create_tmp_table_priv | enum('N','Y') | | | N | |
| Lock_tables_priv | enum('N','Y') | | | N | |
| Execute_priv | enum('N','Y') | | | N | |
| Repl_slave_priv | enum('N','Y') | | | N | |
| Repl_client_priv | enum('N','Y') | | | N | |
| ssl_type | enum('','ANY','X509','SPECIFIED') | | | | |
| ssl_cipher | blob | | | | |
| x509_issuer | blob | | | | |
| x509_subject | blob | | | | |
| max_questions | int(11) | | | 0 | |
| max_updates | int(11) unsigned | | | 0 | |
| max_connections | int(11) unsigned | | | 0 | |
+-----------------------+-----------------------------------+------+-----+---------+-------+
--------------------------------------------------------------------------------
Ogni utente che vuole accedere al server di mysql deve essere inserito qui dentro..
le colonne piu' importanti di questa tabelle sono Host,User,password che guarda caso sono quelle che usiamo su mysql_connect()
Se accedete attraverso PHP sulla vostra stessa macchina il valore di host sarà uguale a localhost e modificando i valori di host potete assegnare diritti diversi a host diversi.
ATTENZIONE!! I diritti attivati in questa tabella sono attivi per qualsiasi db del server Mysql.
La tabella User contiene una serie di colonne che assicurano diritti amministrativi.
Queste colonne sono:
File_priv:
Se concesso Permette al server di database di leggere e scrivere file appartenenti al File System.
Servirà principalmente per caricare un file in una tabella di database
Grant_priv:
Un utente dotato di questo privilegio sarà in grado di assegnare i suoi privilegi ad altri utenti
Proccess_priv:
Questo permette all'utente di vedere e terminare tutti i processi e i thread
Reload_priv:
Viene usata per lo piu' nell'utility mysqladmin per eseguire comandi di scrittura forzata(flush)
attraverso root@ramengo:~# mysqladmin reload
Shutdown_priv:
Permette all' utente di disattivare il demone il demone di mysql utilizzando mysqladmin shutdown
Dalla versioni > 3.23 si sono aggiunti vado a intuito a spiegarli anche perchè sinceramente non li ho mai usati
Create_tmp_table_priv:
Permette la creazione di tabelle temporanee
Execute_priv:
Permette all'utente di lanciare store procedure (MYSQL 5.0)
Lock_tables_priv:
Permette di bloccare le tabelle di un db sulle tabelle che hanno privilegi SELECT attivi
Process_priv:
Penso serva per visualizzare i processi in esecuzione di mysql
Repl_client_priv:
Replication Client permette di conoscere chi è master o chi è slave
Repl_slave_priv:
Necessita di privilegi slave per visualizzare i binlogs come master
Show_db_priv: Permette la visione di tutti i database
Super_priv:
permette unna connessione (unica) se si è raggiunto il limite del max_connections
e permette di eseguire i comandi CHANGE MASTER, KILL thread, mysqladmin debug, PURGE MASTER LOGS and SET GLOBAL
Dalla versione 4.0.0 si ha il supporto per le connessioni SSL criptografate.
Per capire come usare SLL sono necessari alcuni concetti relativi a SSl e X509.
SSL è un protocollo che usa differenti algoritmi di compressione per scambiare i dati in tutta sicurezza.
Utilizza una chiave criptata in X509 che permette di ottenere un tipo di dato illeggibile se non si conosce la chiave di lettura.
X509 è uno standard di cifratura che permette l'identificazione di qualcuno attraverso internet, è generalmente usata nelle applicazioni di E-commerce. le chiavi di cifratura X509, sono assegnate da un ente chiamato 'Certificate Authority' per evitare che qualcuno possa intercettare e leggere il flusso di dati che sono spediti e ricevuti dal Server Mysql usa di default connessioni non criptate tra il Client e il Server perchè significa rendere le connessioni tra i protocolli client/server molto piu' lente e ritardare i task di mysql per via dell'uso intensivo della CPU Di default MySql è ottimizzato per la velocità di esecuzione
ssl_type ssl_cipher x509_issuer x509_subject
le altre colonne contengono per la maggior parte privilegi relativi a istruzioni SQL per la gestione del database :
questi parametri permettono di attivare/disabilitare i diritti di Select/Update/Drop etc
Una piccola nota la spendo su questi 3 campi che possono assegnare limitazioni particolari per ogni utente che ha l'accesso il server MySQL per ogni ora
max_questions:
se si vogliono limitare il numero di query dell'utente
max_updates:
se si vogliono limitare il numero di update dell'utente
max_connections:
se si vogliono limitare il numero di connessioni dell'utente
Tabella DB
code:--------------------------------------------------------------------------------
mysql> show columns from db;
+-----------------------+-----------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+-----------------------+-----------------+------+-----+---------+-------+
| Host | char(60) binary | | PRI | | |
| Db | char(64) binary | | PRI | | |
| User | char(16) binary | | PRI | | |
| Select_priv | enum('N','Y') | | | N | |
| Insert_priv | enum('N','Y') | | | N | |
| Update_priv | enum('N','Y') | | | N | |
| Delete_priv | enum('N','Y') | | | N | |
| Create_priv | enum('N','Y') | | | N | |
| Drop_priv | enum('N','Y') | | | N | |
| Grant_priv | enum('N','Y') | | | N | |
| References_priv | enum('N','Y') | | | N | |
| Index_priv | enum('N','Y') | | | N | |
| Alter_priv | enum('N','Y') | | | N | |
| Create_tmp_table_priv | enum('N','Y') | | | N | |
| Lock_tables_priv | enum('N','Y') | | | N | |
+-----------------------+-----------------+------+-----+---------+-------+
--------------------------------------------------------------------------------
Per tutti i permessi riguardanti database specifici, userete questa tabella piu' o meno funziona come la tabella user, solo che i permessi che sono settati qui dentro valgono solo per il database specificato nela colonna DB.
Tabella TABLES_PRIV e COLUMNS_PRIV
code:--------------------------------------------------------------------------------
mysql> show columns from tables_priv;
+-------------+------------------------------------------------------------------+
| Field | Type | Null | Key | Default | Extra |
+-------------+------------------------------------------------------------------+
| Host | char(60) binary | | PRI | | |
| Db | char(64) binary | | PRI | | |
| User | char(16) binary | | PRI | | |
| Table_name | char(60) binary | | PRI | | |
| Grantor | char(77) | | MUL | | |
| Timestamp | timestamp(14) | YES | | NULL | |
| Table_priv | set('Select','Insert','Update', | | | | |
| | 'Delete','Create','Drop','Grant',| | | | |
| | 'References','Index','Alter') | | | | |
| Column_priv | set('Select','Insert','Update', | | | | |
| | 'References') | | | | |
+-------------+-----------------------------------+------+-----+---------+-------+
--------------------------------------------------------------------------------
Siccome TABLE_PRIV e COLUMNS_PRIV sono molto simili in queste tabelle sono memorizzati rispettivamente i diritti degli utenti che possono accedere ad una tabella piu' tabelle tutti i diritti per le utenze vengono concentrate nelle ultime due righe della tabella Istruzioni GRANT e REVOKE , Inserimento e cancellazione Utenti mysql
Allora come si procede all'inserimento nei diritti delle tabelle???
Ci sono 2 modi uno è il buon vecchio SQL
1) INSERIMENTO ATTRAVERSO QUERY
INSERIMENTO DI UN UTENTE
es: INSERT INTO user (Host,User,Password) VALUES ('localhost','pippo',password('figo'))
password serve per fare un ascing della password su Db ma se lo facciamo in MD5 è piu' sicuro
code:--------------------------------------------------------------------------------
+-----------+-------+------------------+
| host | user | password |
+-----------+-------+------------------+
| localhost | root | |
| marantega | root | |
| localhost | | |
| marantega | | |
| % | pippo | 09e7d92b43759e6c |
| localhost | tocio | paperoga |
+-----------+-------+------------------+
--------------------------------------------------------------------------------
ATTENZIONE!!!! se si modificano le tabelle di grant, come la tabella user, direttamente con i comandi di manipolazione delle tabelle, il server MySQL non si accorge automaticamente del cambiamento e continua ad autenticare gli utenti con le vecchie informazioni. Per forzare il server a leggere i nuovi diritti, occorre dare il comando FLUSH PRIVILEGES che richiede il privilegio RELOAD che abbiamo visto in precedenza per essere eseguita.
AUTENTICAZIONE A CARATTERI JOLLY
Se non ci fosse la possibilità di inserire caratteri jolly e utenti anonimi, la decisione se un utente può accedere o no al database sarebbe semplice. Con i caratteri jolly la cosa si complica. Ad esempio, se io sono l'utente pippo che si collega da localhost devo inserire la password oppure no? Infatti in teoria l'utente pippo@localhost potrebbe connettersi al database sia grazie alla riga:
code:--------------------------------------------------------------------------------
+-----------+-------+------------------+
| host | user | password |
+-----------+-------+------------------+
| localhost | | |
+-----------+-------+------------------+
--------------------------------------------------------------------------------
localhost (cioè un utente anonimo da localhost) o tramite la riga
code:--------------------------------------------------------------------------------
+-----------+-------+------------------+
| host | user | password |
+-----------+-------+------------------+
| % | pippo | 09e7d92b43759e6c |
+-----------+-------+------------------+
--------------------------------------------------------------------------------
(l'utente pippo da un macchina qualunque).
MySQL da più importanza al nome dell'host che al nome dell'utente. Quando il client tenta di connettersi, MySQL ordina la tabella utenti dagli host più specifici a quelli più generici.
Ad esempio, abbiamo, dal più specifico al più generico:
localhost (che identifica una macchina qualunque)
'%.html.it' (che specifica una qualunque macchina da html.it)
'%' (che identifica una macchina qualunque).
Una volta ordinato in questo modo, esamina una riga alla volta fino a trovare la prima che corrisponde all'utente che vuole collegarsi, e usa l'informazione ricavata da essa. Per far ciò considera, a parità di host, prima i nomi utenti non vuoti e poi i nomi utenti (che corrispondono ad un utente generico). Ad esempio, nel nostro caso, pippo@localhost non ha bisogno di password, in quanto viene utilizzata per l'autenticazione la riga
code:--------------------------------------------------------------------------------
+-----------+-------+------------------+
| host | user | password |
+-----------+-------+------------------+
| localhost | | |
+-----------+-------+------------------+
--------------------------------------------------------------------------------
che ha l'host più spcecifico e non la riga
code:--------------------------------------------------------------------------------
+-----------+-------+------------------+
| host | user | password |
+-----------+-------+------------------+
| % | pippo | 09e7d92b43759e6c |
+-----------+-------+------------------+
--------------------------------------------------------------------------------
CANCELLAZIONE DI UN UTENTE DAL DB
Per eliminare o modificare i diritti ad un utente useremo il comando DELETE per la cancellazione e UPDATE per la modifica
ed eseguire successivamente FLUSH privileges
ATTENZIONE!! Dovete accedere a MySQL con un' utenza che permetta la modifica del database mysql.
2) ISTRUZIONI GRANT , REVOKE e FLUSH
GRANT
Per evitare l'inserimento manuale e inserire tutti i campi delle tabella esiste la funzione GRANT
code:--------------------------------------------------------------------------------
mysql> grant all on poenta.* to tocio@localhost
identified by "papeperoga";
--------------------------------------------------------------------------------
Questo comando farà in automatico tutti i cambiamenti alle tabelle necessarie al posto vostro.
la prima parte dell' istruzione grant può usare la parola all, oppure una qualsiasi delle opzioni elencate nella tabella User
per lo piu' le istruzioni SQL (select,create,drop,index,etc..).
La seconda parte (on poenta.*) dell'istruzione grant identifica dove i privilegi verranno applicati
i livelli di permessi sono i seguenti
grant all on *.* = Diritti universali i privilegi sono inseriti nella tabella User
grant all on database.* = Si applica su tutte le tabelle di un solo database
grant all on database.table_name = Si applica su una singola tabella
grant all(col1, col2) on database.table_name = Si applica a determinate colonne di una tabella di un database
La terza parte (to tocio@localhost) indica indica l'utente al quale consentire l'accesso.
Come abbiamo visto in precedenza il MySQL richiedesia un nome sia un host. Nell'istruzione grant i due sono separati dal simbolo @ la quarta parte (identified by "papeperoga")attribuisce una password all'utente.
Per esaminare i diritti di un utente possiamo digitare
code:--------------------------------------------------------------------------------
mysql> show grants for tocio@localhost;
+---------------------------------------------------------------------+
| Grants for tocio@localhost |
+---------------------------------------------------------------------+
| GRANT ALL PRIVILEGES ON *.* TO 'tocio'@'localhost' WITH GRANT OPTION|
+---------------------------------------------------------------------+
--------------------------------------------------------------------------------
Tutto quello che dovete conoscere è lo username e la password.
REVOKE
Se volete togliere alcuni privilegi a un utente, potete usare un REVOKE
es: revoke shutdown on *.* from tocio@localhost è come il GRANT fa il contrario l'unica differenza nella sintassi è il from anzichè to per rimuovere del tutto l'utente dovete fare tenendo condo che l'utente è identificato da un nome e un host delete from user where user='user' and host='host'
FLUSH
Questa funzione vi permette di ricaricare i diritti appena concessi senza utilizzare GRANT per ricaricarli useremo
code:--------------------------------------------------------------------------------
mysql> flush privileges
--------------------------------------------------------------------------------
Nella tabella "tables_priv" del DB mysql nella colonna "Grantor" cosa va inserito? è il nome dell'utente di chi chi sta facendo il grant dei privilegi.. ^__^ è solo un etichetta alla fine per conoscere chi ha assegnato i diritti a quella tabella..
Corregimi se sbaglio quindi dovrebbe essere chi gestisce le tabelle dei privilegi (tipo root@... o chi per lui) penso proprio che sia una cosa del genere.. quindi se ho un server con l'accesso root a mysql
con siti che usano il database dovrei impostare i permessi per evitare casini!
possiamo fare un esempio tanto per comprendere meglio il concetto?
ho il sito test.it e prova.it
per i quali ho creato rispettivamente il database test.it e prova.it ora che dovrei fare? devi assegnare dei permessi agli utenti dei database per evitare che il proprietario di prova.it possa modificare i database pure di test.it l'utente prova.it dovrà avere permessi solo per il suo Db non dovrà accedere al db di amministrazione revocare e garantire permessi altrimenti può succedere un macello ..
Quindi andando per gradi prima devo creare un utente inserendolo nella tabella user:
>Host = localhost oppure posso scrivere liberamente quello che mi pare tipo "mysql.prova.it" o ce da fare qualche altra cosa prima?
>User = prova.it nome attinente al dominio
>Password = da 8 a 32 caratteri criptata
>Le altre opzioni non mi sembrano facili quelle critiche da tenere sul no sono solo drop_priv che consente la cancellazione dei db?
Poi dovrei passare alla tabella db e cosa dovrei inserire per dire che l'utente porva.it può accedere solo al db "prova.it"
Host: localhost o altro nome scelto?
db: prova.it
User: prova.it
e mettere sul no
Drop_priv
e poi...
grant all on prova.it.* to nomeutente@localhost
identified by "passwordutente";
così gli dai tutti i privilegi
per maggiori info e per chiarirti un pò piu' le idee ti linko la guida ufficiale
http://dev.mysql.com/doc/mysql/en/Adding_users.html 
http://dev.mysql.com/doc/mysql/en/GRANT.html 

Scrivere la data e l'ora
Per scrivere la data e l'ora in formato italiano sulle nostre pagine Php basta usare le istruzioni setlocale() e strftime().
Ecco un esempio:
<?PHP
setlocale("LC_TIME", "it_IT");
print(strftime ("%A %d %B %Y %H:%M"));
?>

Creare un blog in PHP senza bisogno di MySQL
Creiamo dapprima il sistema per l'accesso all'interfaccia di inserimento messaggi. Ecco il codice della pagina HTML di accesso, che chiameremo "amministra.htm":
<html>
<head>
<title>Amministrazione Blog</title>
</head>
<body>
<form name="form1" method="post" action="accedi.php">
<div align="center">
<input name="utente" type="password" id="utente" size="40">
<input type="submit" name="Submit" value="Invia">
</div>
</form>
</body>
</html>
Da notare che contiene un form che invia i dati alla pagina "accedi.php". Salviamo e chiudiamo questo file e passiamo alla realizzazione di quest'ultima, accedi.php.
Ecco il codice:
<?php
if ($utente!="password")
{
header("Location: accessonegato.htm");
exit;
}
?>
<html>
<head>
<title>Blog</title>
</head>
<body>
<form name="form1" method="post" action="inserisci.php">
Inserisci titolo
<input name="titolo" type="text" id="titolo" size="50">
Inserisci testo
<textarea name="testo" cols="50" rows="10" wrap="VIRTUAL" id="testo"></textarea>
<input type="submit" name="Submit" value="Invia">
</html>
Creiamo la pagina "accessonegato.htm", a cui l'utente sarà indirizzato nel caso la password digitata fosse errata.
<html>
<head>
<title>Accesso negato</title>
</head>
<body>
<p align="center"><h3><b>Accesso negato!</b></h3></p>
<p align="center">La password inserita non è corretta.</p>
</body>
</html>
Logicamente questa pagina può essere personalizzata a piacere... noi abbiamo lasciato una struttura semplice e chiara per non fare troppa confusione.
Ora creiamo la pagina "inserisci.php", che conterrà il codice PHP per scrivere il messaggio all'interno di "database.htm", la pagina-database che conterrà i nostri messaggi.
Ecco il codice:
<?php
$nomefile="database.htm";
$vecchiofile=fopen($nomefile, "r");
$contenuto_file=fread($vecchiofile, filesize($nomefile));
fclose($vecchiofile);
$data=(date("d-m-Y"));
$ora=(date("H:i:s"));
$f=fopen($nomefile, "w+");
fwrite($f, "<table width=\"600\" border=\"0\" cellspacing=\"5\"
cellpadding=\"2\"><tr>\r\n");
fwrite($f, "<td width=\"450\" bgcolor=\"#A20007\">
<font color=\"#FFF45F\" size=\"2\" face=\"Arial, Helvetica, sans-serif\">$titolo</font></td>\r\n");
fwrite($f, "<td width=\"150\" bgcolor=\"#A20007\">
<font color=\"#FFF45F\" size=\"2\" face=\"Arial, Helvetica, sans-serif\">$data alle $ora</font></td>\r\n");
fwrite($f, "</tr><tr>\r\n");
fwrite($f, "<td colspan=\"2\"><font size=\"2\" face=\"Arial, Helvetica, sans-serif\">$testo</font></td>\r\n");
fwrite($f, "</tr></table>\r\n");
fwrite($f, "<br>\r\n");
fwrite($f, "$contenuto_file\r\n");
fclose($f);
?>
<html>
<head>
<title>Messaggio inserito correttamente</title>
</head>
<body>
<p align="center>Messaggio inserito correttamente
<br>
<a href="blog.php">Visualizza il tuo blog</a></p>
Creiamo "database.htm", il file su cui lo script andrà a scrivere i messaggi.
Apriamo il blocconotes e salviamo il file bianco e senza nessun tag di codice come "database.htm".
Passiamo ora alla creazione di "blog.php", la pagina pubblica che conterrà il blog e sarà visibile da tutti gli utenti e i visitatori.
Ecco il codice:
<html>
<head>
<title>Il mio blog</title>
</head>
<body>
<p align="center"><h3>Il mio blog</h3></p>
<?php include("database.htm"); ?>
</body>
</html>
Da notare di questo file la stringa di codice PHP:
<?php include("database.htm"); ?>
Essa è centrale di tutto lo script. Con il comando INCLUDE richiamiamo il database contenente i messaggi, in modo che essi siano mostrati nella index del blog, ossia la pagina visibile da tutti ("blog.php").
Logicamente si tratta di un file totalmente personalizzabile... potete crearlo con il vostro editor HTML e poi aggiungere la stringa PHP nel punto in cui volete che siano mostrati i messaggi.

PHP.INI
Per l'analisi delle configurazioni principali di php.ini prendiamo in esame il php.ini-dist che presenta un tipo di configurazione meno esasperata e più user friendly nonchè oggettivamente più utile per la programmazione.
Cominciamo con il dire che php.ini gestisce tutte le configurazioni possibili (eccezion fatta per le modalità di installazione e compilazione).
I settaggi che metterò negli esempi sono quelli di default
La logica è davvero molto semplice, in pratica corrisponde a questo esempio:
settaggio = value
Permette l'utilizzo dei tag abbreviati
short_open_tags = On
Permette l'utilizzo di tag ASP
asp_tags = Off
Il numero di cifre significative nei numeri a virgola mobile
precision = 12
Forza la compatibilità con l'anno 2000 (crea problemi con non-compliant browser)
y2k_compliance = Off
Abilitazione del buffering dell'output. Settando "On" questa configurazione permetterete a PHP di inviare la pagina al browser solo al termine dell'esecuzione di tutti gli script e tutte le varie funzioni di echo o print venrranno immagazzinate nel buffer. Questo ha il vantaggio di permettere l'invio di header lines anche dopo l'invio del body. Inoltre nel caso che nella maggioranza delle pagine ci sia commistione di html tradizionale e html generato da php attraverso echo() o print().
Oppure qualora si senta l'esigenza di comprimere l'output per velocizzare lo scaricamento delle pagine (attivando nel php.ini sia il buffering che la compressione). Lo svantaggio principale è di rallentare l'esecuzione del codice PHP nel caso che lo script non sfruttati appieno queste opportunità.
Nel caso che il server fornisca hosting a diversi clienti è preferibile lasciare queste opzioni disabilitate e lasciare la libertà ai programmatori di sfruttare il buffering con le funzioni ob_start etc...
output_buffering = Off
Puoi redirezionare l'output degli scripts verso una funzione. Ad esempio impostando output_handler a ob_gzhandler, l'output verrà trasparentemente compresso per i browser che supportano gzip o browser che scompattano il codice.
output_handler =
Rende trasparente la compressione tramite le librerie gzip. Le impostazioni valide sono 'Off' 'On' o specificando il buffer size da utilizzare per la compressione (default = 4 Kbyte)
Importante: se si imposta questa configurazione ad 'On' output_handler DEVE essere settata 'On'
zlib.output_compressed = Off
Implicit flush è una opzion che deve essere settata Off, al massimo deve essere utilizzata solamente in fase di debugging in quanto ha gravi conseguenze sulle performance
implicit_flush = Off
Impostando "on" si forza a passare per reference gli argomenti quando viene chiamata la funzione. Questo metodo è deprecato (anche se di default è settato On) e viene consigliato di sistemare gli script per funzionare anche se questa configurazione è settata ad "on" in quanto in futuro verrà cancellata.
allow_call_time_pass_reference = On
Safe mode effettua un rigido controllo sugli utenti che "girano" nello spazio web in cui vengono eseguiti script php.
Normalmente tutti gli script ereditano i permessi di Apache (che con certe configurazioni del server possono rivelarsi troppo ampi), invece dal momento in cui viene attivato safe_mode, gli script agiranno strettamente con i permessi dell'utente che li ha uplodati (cioè, in uno spazio in hosting, l'utente ftp), quindi, ad esempio, non potranno andare a leggere un file creato con php nello spazio WEb di un altro utente (revisionato da Fabio Heller)
safe_mode = Off
Di default safe mode quando viene aperto un file fa un UID compare. Se vuoi "rilassare" il tuo script ad un GID compare bisogna impostare la seguente impostazione ad "On"
safe_mode_gid = Off
Quando il safe mode è impostato su "On" il controllo UID/GID è bypassato quando viene incluso un file da quella directory e dalle sue sottodirectory
safe_mode_include_dir =
Se si imposta "On" dice a PHP di dichiararsi presente sul server
expose_php = On
Limiti risorse:
Tempo massimo di esecuzione di uno script PHP
max_execution_time = 30
Massima quantità di memoria che uno script PHP può occupare per la sua esecuzione
memory_limit = 8M
Gestione degli errori (per maggiori dettagli in php.ini vengono spiegati i vari livelli di visualizzazione degli errori)
Questa configurazione mostra tutti gli errori eccetto le notifiche
error_reporting = E_ALL & E_NOTICE
Visualizzazione errori come parte dell'output della pagina.
Questa opzione deve essere impostata "On" SOLO per siti in sviluppo, per server in produzione è vivamente consigliato di spegnere questa configurazione e di utilizzare il logging interno di PHP (più avanti spiegato) perchè potrebbe visualizzare informazioni critiche come il path dei file
display_errors = On
Anche quando display_errors = On, gli errori occorsi durante la sequenza di startup di PHP non vengono visualizzati. E' fortemente raccomandato per server in produzione di disattivare questa funzionalità
display_startup_errors = Off
Logging degli errori in un file di log. Il team di php.net avvisa di attivare questa opzione per server in produzione
log_errors = Off
Memorizza l'ultimo errore/warning in $php_errormsg (boolean)
track_errors = Off
Disabilita l'inclusione di tag HTML negli errori
html_errors = Off
Log errors in uno specifico file (valido se log_errors = On)
error_log = filename
IMPORTANTE! la configurazione di questo parametro è molto importante perchè definisce la compatibilità con vecchie versioni di PHP in qui era impostata di default ad "On" mentre ora per motivi di sicurezza è consigliato settare ad "Off" Regiter Globals.
In breve questa funzione permette di non dover richiedere una variabile passata in un URL come GET o come POST ma di averla già disponibile.
Se register_globals = On nel caso di un url del tipo: http://www.dominio.com/pippo.php?ID=56 se nella pagina successiva printo $ID il PHP visualizzerà 56, nel caso di register globals = Off la variabile sarà disponibile solamente in $_GET["ID"] o con le vecchie variabile in $HTTP_GET_VARS["ID"] e non come $ID
register_globals = On
Questa direttiva dice a PHP di dichiarare le variabili argv&argc (quelle contanenti le informazioni GET). Se non si usano queste variabili si può spegnere questa configurazione per ottenere maggiori performance.
register_argv = On
Massima dimensione di un POST di dati che PHP accetti
post_max_size = 8M
Questa direttiva è deprecata e php.net consiglia di utilizzare l'altra variabile di ordinamento dei GET POST COOKIE spiegata precedentemente
gpc_order = "GPC"
Importante: Magic quotes
Magic quotes per variabili in ingresso GET/POST/COOKIE: Vuol dire che a tutte le variabili in incoming come GPC vengono aggiunti gli slashes. Es. ' = \' " = \"
magic_quotes_gpc = On
Magic quotes per dati runtime (Es. dati da SQL, da exec etc...)
magic_quotes_runtime = Off
Utilizza magic quotes stile sybase (escape per ' con '' anzichè \')
magic_quotes_sybase = Off
Directory dove risiedono le estensioni
extension_dir = ./
Configurazione per enablare o meno le dl() function che non funzionano correttamente su multithread server, IIS e Zeus e vengono automaticamente disabilitate in questi server
enable_dl = On
File Uploads
Impostare il permesso di HTTP upload di files
file_uploads = On
Directory dei file temporanei in fase di upload (se commentate questa configurazione verrà utilizzata quella di default del S.O.)
upload_tmp_dir
Massima dimensione di un file accettata da PHP
upload_max_filesize = 2M
File Opening
Configurazione per concedere la possibilità del trattamento con fopen di URL file
allow_url_fopen = On
Dinamic extension
Windows extensions (se commentata non viene caricata) un esempio:
extension = php_cpdf.dll
Module settings
Configurazione per attivazione dei syslog (disabilitare questa opzione permette un incremento delle performance di PHP)
define_syslog_variables = Off
Funzioni email per windows
Impostazione SMTP server
SMTP = localhost
Invio email da:
sendmail_from = me@localhost.com
Funzioni email per unix
Path di sendmail
;sendmail_path = (commentata di default)
Configurazioni database
SQL
sql.safe_mode
ODBC
Permette o previene connessioni persistenti
odbc.allow_persistent = ON
Controlla che la connessione persistente sia valida prima di utilizzarla
odbc.check_persistent = On
Massimo numero di connessioni persistenti (-1 equivale ad infinite)
odbc.links = -1
MYSQL
Per eventuali configurazioni del tipo mysql.allow_persistent = On valgono le spiegazioni date per ODBC e così per i database supportati. (tratterò esclusivamente i casi specifici di ogni DB).
Porta di default di mySQL. Se lasciata blank viene utilizzata la porta di default 3306
mysql.default_port =
Nome socket per connessioni locali a mySQL. Se vuota viene utilizzata quella di default
mysql.default_socket = On
Default host per mysql_connect() (non applicabile in safe mode)
mysql.default_host
Default user per mysql_connect() (non applicabile in safe mode)
mysql.default_user =
Default password per mysql_connect() (non applicabile in safe mode). E' assolutamente sconsigliabile utilizzare una password di default!!
mysql.default_password =
POSTGRESQL
Individua connessioni persistenti broken con pg_connect(). Necessita di un piccolo overhead
pgsql.auto_reset_persistent = Off
SYBASE
Error severity minimo visualizzato
sybase.min_error_severity = 10
Si forza la compatibilità con versioni vecchie di PHP (3.0) in caso di settaggio ad On forza PHP a assegnare tipi di risultati del tipo di quelli di sybase.
Questa compatibilità non rimarrà a lungo
sybase.compatibility_mode = Off
SYBASE-CT
Massimo numero di connessioni (persistenti e non) accettate da sybase (-1 senza limiti)
sybct.max_links = -1
N.b.Non mi dilungherò ulteriormente sui database in quanto indicativamente per tutti i database le configurazioni sono simili, ci sono altri casi eccezionali comunque descritti ampiamente in PHP.INI
SESSIONI
Handler utilizzato per lo store ed il retrieve dei dati
session.save_handler = files
Path dove vengono immagazzinati i files delle sessioni
session.save_handler = /tmp
Se usare i cookies
session.use_cookies = 1
Nome della sessione (usato come cookie name)
session.name = PHPSESSID
Inizializzazione sessioni alla richiesta di startup
session.auto_start = 0
Tempo di vita del cookie (se 0 finchè il browser non viene restartato)
session.cookie_lifetime = 0
Path per il quale il cookie è valido
session.cookie_path = /
Handler utilizzato per la serializzazione dei dati (lo standard è PHP)
session.serialize_handler = php
Percentuale di possibilità che la "Garbage Collection" venga iniziata quando la sessione viene inizializzata
session.gc_probability = 1
Importante: Numero di secondi dopo il quale la sessione viene considerata scaduta (importante in caso di carrelli della spesa)
session.gc_maxlifetime = 1440
Controlla l'HTTP referer per la validazione di stored URL che contengono l'ids
session.referer_check =
Quanti bytes vengono letti dal file
session.entropy_lenght = 0
Specifica dove creare il session ID
session.entropy_file =
Setta il no cache
session.cache_limiter = nocache
Tempo di espirazione del documeto in N minuti
session.cache_expire = 180
E' molto rischioso abilitare il trans sid perchè permette di accedere ad una sessione tramite vecchi bookmarks o url stored e perchè l'utente può inviare l'URL contenente la sessione via mail, irc etc...
sessione.use_trans_sid = 0

E con questa ultima spiegazione ho terminato di trattare le configurazioni principali di php.ini
Esempio di configurazione per un sito in produzione (da prendere con le molle e da customizzare in base alle proprie esigenze) PHP.INI

PHP.INI - register_global disattivato
Dalla versione 4.2.0 gli sviluppatori di PHP hanno deciso di rivoluzionare la gestione delle variabili provenienti dall'utente e hanno deciso di impostare nel file di configurazione
php.ini la variabile register_global = Off di default non permettendo più  il comodissimo ma insicuro sistema di assegnazione automatica ad una variabile del suo valore passato dall'esterno.
La comodità stava nel fatto che se passavo ad uno script “pippo.php?io=max” avevo direttamente disponibile la variabile $io che assumeva il valore “max”. Questo sistema era decisamente molto comodo e facilitava il compito del programmatore ma creava dei problemi di sicurezza per chè anche se nel php.ini era presente la configurazione variables_order che impostava la priorità con cui dovevano essere gestite le assegnazioni di una variabile da una GET, POST, COOKIE o SESSION c'era l'inconveniente che se un programmatore prevedeva un controllo su una variabile $control e un utente smaliziato passava allo script tramite GET control=qualcosa il controllo del programmatore veniva eluso e di conseguenza si apriva una falla gigantesca nell'applicazione.
Il problema è che tutte o quasi le applicazioni realizzate prima della versione 4.2.0 sono state sviluppate con l'impostazione delle variabili globali impostata ad On e per questa ragione chiunque offra hosting a webmaster esterni sarà costretto a mantenere questa configurazione per non compremettere la funzionalità delle applicazioni presenti sul proprio server web.
Comunque sia d'ora in avanti chi svilupperà software in PHP per mantenere una portabilità ed una longevità nonchè sicurezza intrinseca dovrà cercare di sviluppare considerando che register_global sia uguale ad Off perchè prima o poi gli sviluppatori di PHP forzeranno con una versione nuova gli hoster ad utilizzare la nuova configurazione.

 

MySQL Field Types

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
 


 


UTILITY PHP

USBWebServer 8 (OTTIMO!!!!)
USBWebserver v8.5
New in this version
My.ini bug fix
More php extensions
PHP Version 5.3.9
Apache 2.2.21
PhpMyAdmin 3.4.9.0
MySQL 5.5
* 18-01-2012: added Spanish language file
* 19-01-2012: added Portuges language file
USBWebserver is Free for use.
Because USBWebserver is provided and maintained by volunteers, we appreciate donations.
With these donations will we able to keep developping USBWebserver.
What is USBWebserver?
USBWebserver is a combination of the popular webserver software: Apache, MySQL, Php and PhpMyAdmin. With USBWebserver it is possible to develop and show your php websites, everywhere and anytime The advantage of USBWebserver is, you can use it from USB of even CD
USBWebserver is perfect for:
Show a offline version of your website
Anywhere and anytime develop php websites
No need for expensive hosting
Working at multiple locations at projects
A good test before putting your website online
And many more
http://www.usbwebserver.net/en/download.php

MoWes
Modular Webserver System. Il software in questo pacchetto è compatibile con qualsiasi versione di Windows.
Contiene Apache, PHP, MySQL, Zend Optimizer, e si possono scaricare dal sito anche TYYPO3, Joomla, Mambo, WordPress, Moodle, OS Commerce, Drupal, PHPMyAdmin
http://www.moweshelp.chsoftware.net

NetServer
(Hosting@home)
It is a project I developed to easily have a full featured webserver quickly for the Windows Operating System.
NetServer includes the most popular open-source servers and uses the stable versions of those servers...
The main feature of NetServer is the Graphical User Interface (GUI) which is developed with the intention of giving the user all the control it needs for each server, in just a few clicks you can install a server, configure it, and start it...You don´t need to edit textfiles to make them work at all...
Just click and run...
The best thing of it all is the price. NetServer is FREE Software and also open-source.
NetServer includes the following servers :
- Apache Webserver - http://httpd.apache.org/
- MySQL Database Engine - http://www.mysql.com
- Filezilla FTP Server - http://filezilla.sourceforge.net
- hMailServer - http://www.hmailserver.com
Besides the servers, NetServer also comes with a few tools to administer your servers, they are web-based tools developed in PHP scripting language.
NetServer includes the following PHP scripts :
- phpMyAdmin (For MySQL server administration)
- SquirrelMail (Webmail for your hMailServer accounts)
- phpWebAdmin for hMailServer (is a PHP GUI for configuring hMailServer)

http://netserver.hugosoft.net

GoPenServer
GoPenServer (Go-Open-Server) è un server HTTP/FTP che include Apache, MySQL, PHP, Perl e phpMyAdmin.
Contiene anche alcuni software per la creazione di pagine web come Nvu, GIMP, e Fully Modded phpBB2.
Al suo interno è già presente Audacity, un editor e registratore audio semplice e libero, disponibile per Windows, Mac OS X, GNU/Linux, e altri sistemi operativi.
È un freeware, quindi la sua distribuzione è gratuita, senza nessuna limitazione.
http://gopenserver.sourceforge.net/
http://gopenserver.sourceforge.net/mediawiki/index.php/Main_Page
http://gerfulsworld.wordpress.com/
http://download.html.it/software/vedi/3185/gopenserver/

Pampa
Acronico di Portable Apache -  Mysql - PHP Apllication, è un'applicazione con interfaccia grafica che permette di lanciare un webserver, database e moduli collegati senza bisogno di installazione. Utile quando si vuole presentare un sito dinamico in un ambiente di prova temporaneo.
P.S.
1 - Anche se si tratta di un'applicazione che può essere eseguita senza bisogno di installazione, per copiarla su un supporto rimovibile è necessario almeno installarla una prima volta. Poi basterà copiare l'intera cartella nella posizione desiderata (da c:\programmi\pampa).
2 - Per motivi di sicurezza, MySql non viene lanciato in maniera automatica all'avvio dell'applicazione. Se si desidera cambiare questa opzione, basterà modificare l'impostazione predefinita partendo dal menù Settings/AutoLaunch Mysql.
3 - Utilizzando l'avvio automatico di Mysql, un cd con autorun correttamente configurato e con la possibilità di lanciare ulteriori programmi dopo l'avvio (modificando il file "runafterstart.ini), si può ottenere un'applicazione web che parta automaticamente appena viene inserito il cd.
4 - E' possibile scaricare soltanto l'applicazione grafica di Pampa e scegliere autonomamente le versioni di Apache, Mysql e PHP da utilizzare, così come aggiungere moduli aggiuntivi, per esempio Perl, Python, PostgresSQL, Zend accelerator ecc.
http://pampa.phpsoft.it/

Un WebServer completo su una chiavetta USB (WebserverOnStick) - esiste una traduzione in italiano dei messaggi e dei comandi
http://www.chsoftware.net/en/useware/wos/wos.htm
Technical infos:
- Apache 2.2.0
- MySQL 5.0.18
- PHP 4.4.2/PHP 5.1.2.2
- PhpMyAdmin 2.8.0.3
You need about 200/250 MB space for the normal version! If you think this is too much you can use the small version (~20 MB).
Il programma funziona sotto Windows9x, 2000 e XP.
Dopo aver scompattato l'archivio, salvare il Web server in una cartella qualsiasi e copiare poi l'intera cartella sulla propria chiavetta USB. Il web server è immediatamente avviabile, non richiede infatti, un'installazione sul supporto removibile e neppure sul disco fisso.
Inserire la chiave e fare doppio clic su Start.exe per avviare il server. Successivamente si dovranno effettuare alcune impostazioni di base, come l'impostazione della lingua da utilizzare.
Si consiglia di adoperare PHP versione 4.x, poichè talvolta compariranno alcuni messaggi di errori, legati al file DLLphp_gd2.dll.
Come cartella d'origine viene usata la cartella /www: i file html e php vanno quindi salvati in questa cartella.

BitNami
Una soluzione particolarmente comoda e innovativa per poter allestire in pochi click una piattaforma Apache e MySQL. Successivamente è possibile installare "moduli" aggiuntivi per poter utilizzare i più disparati CMS OpenSource.
http://bitnami.org/

Server2Go - Web server
Server2Go è un Webserver che funziona senza alcuna installazione. Questo significa che è un Webserver che può funzionare da un cdrom, da una pendrive o da una qualunque cartella sull'hard disk. Server2GO ti permette di creare siti web funzionanti "standalone" o applicazioni PHP su un CD-ROM. Server2Go è stato sviluppato principalmente per l'uso da cd, ma non ci sono problemi ad usarlo da altri drive. Usando un browser, un utente può avviare, dal cdrom, programmi in php tanto come se vedesse delle pagine html. Ha bisogno solo di inserire un cd con Server2Go su un sistema operativo Windows. Il server si avvia automaticamente e apre il browser con il sito contenuto nel cdrom.
http://www.server2go-web.de/

FAQ: risolvere l'errore Allowed memory size of 8388608 bytes exhausted
Dopo aver inserito una nuova voce di menu nel pannello di
amministrazione, l'elenco non viene ricaricato e mi appare solo
l'errore:
Fatal error: Allowed memory size of 8388608 bytes exhausted
Come posso risolverlo?
--------------------------
L'errore si riferisce ad un problema di memoria non sufficiente e si verifica quando per eseguire una determinata pagina PHP il server è costretto ad allocare una quantità di memoria superiore a quella riservata all'esecuzione di uno script. In taluni casi si manifesta semplicemente con una pagina bianca (non viene caricato alcunchè) ed in questi casi per capire la natura dell'errore occorre dare un'occhiata al file di log degli errori del server (error.log).
E' comunque relativamente semplice rimediare a questo errore in almeno tre modi:
1) MODIFICANDO IL FILE php.ini
Questa opzione è adatta a coloro che dispongono di un server proprio (anche virtuale) e non è in genere disponibile sui normali hosting commerciali perchè prevede la modifica del file di inizializzazione dell'interprete PHP.
Si tratta comunque della soluzione migliore e chiunque sia nelle condizioni non deve fare altro che 1.1) aprire il file etc/php.ini con un comune editor di testo (ad esempio, il blocco note di windows) 1.2) individuare la riga: memory_limit = 8M (8M è il valore di default ma potrebbero esserci altri valori) 1.3) aumentare questo valore in maniera opportuna, ad esempio scrivendo: memory_limit = 12M 1.4) riavviare il server
2) MODIFICANDO IL FILE .htaccess Questa opzione è adatta a coloro che non hanno accesso al file php.ini perchè, ad esempio, usufruiscono di un servizio di hosting ma hanno comunque la possibilità di modificare il file .htaccess della directory principale del sito. In questo caso, è sufficiente: 2.1) aprire il file .htaccess con un comune editor di testo 2.2) aggiungere la seguente riga: php_value memory_limit 12M dove al solito il valore dei MB può essere modificato secondo necessità (qualora 12 non dovesse essere sufficiente)
3) MODIFICARE IL SINGOLO FILE PHP IN CUI SI E' VERIFICATO L'ERRORE Quando le prime due opzioni non sono disponibili, ad esempio perchè il servizio di hosting non permette nemmeno modifiche al file .htaccess, l'ultima possibilità per risolvere il problema consiste nell'individuare il file PHP in cui si verifica l'errore ed aggiungere all'inizio del codice la seguente riga: ini_set("memory_limit","12M"); che ha l'effetto di modificare la dimensione della memoria allocata ma solo localmente, ossia solo per l'esecuzione di quel particolare file. Ovviamente, nulla vieta di ripetere questo procedimento per più file se l'errore si manifesta anche altrove.
------
you must change it in:
Code:
<your S2G>\server\config_tpl\php.ini
From my personal notes:
Code:
# to import exported DB file php.ini had to be changed to overcome Max: 2,048KiB for import size
# server2go_a2_psm_JJC\server\config_tpl\php.ini:
; Maximum allowed size for uploaded files.
;upload_max_filesize = 2M
upload_max_filesize = 20M
I also encountered some other php.ini related issue I am now just listing here:
Quote:
# Allowed memory size error:
Fatal error: Allowed memory size of 8388608 bytes exhausted (tried to allocate 88 bytes) in C:\IK\private\server2go_a2_psm_JJC\htdocs\gallery2\modules\core\classes\GalleryUtilities.class on line 1234
# was fixed by:
# S2G is just using the default value for the memory amount used by PHP. Your media wiki seems to need more than the default 8MB. You can easily change this by changing the parameter memory_limit in the php.ini config file to a higher value (16M or 32M...). For that just open the php.ini file in the folder server/config_tpl
# open:
server2go_a2_psm_JJC\server\config_tpl\php.ini
# new value:
memory_limit = 32M ; Maximum amount of memory a script may consume (8MB)
# gettext error:
# Your webserver does not support localization. To enable support for additional languages please instruct your system administrator to reconfigure PHP with the gettext option enabled.
# open:
server2go_a2_psm_JJC\server\config_tpl\php.ini
# uncommented:
extension=php_gettext.dll

PHP Home Edition 2.3.4
PHP Home Edition is a complete package including WWW server Apache, DBS Server MYSQL and scripting language PHP into one fully operational system. Including additional compiled libraries for Win32 OS and many more. Easy to install, plug and play installat
* Development Status: 5 - Production/Stable
* Intended Audience: Developers, End Users/Desktop, System Administrators
* License: GNU General Public License (GPL)
* Operating System: 32-bit MS Windows (95/98), 32-bit MS Windows (NT/2000/XP), All 32-bit MS Windows (95/98/NT/2000/XP), Win2K, WinXP
* Programming Language: PHP
* Topic: Database Engines/Servers, Dynamic Content
* Translations: English
* User Interface: Win32 (MS Windows)
Pacchetti inclusi:
+ apache 2.0.50
+ MYSQL Stable 4.0.20a/d
+ php 5
+ phpmyadmin 2.6.x
http://phphome.sourceforge.net/ 

INSTALLAZIONE COMPLETA ED EX NOVO DI UN SERVER PHP, APACHE E MYSQL SOTTO WINDOWS Vedi (**************)
Installare Apache 2, PHP 5, MySQL 4.1 su Windows
Versione stampabile: http://www.phpnews.it/index2.php?option=com_content&task=view&id=67&Itemid=80&pop=1&page=0 
http://www.phpnews.it/index.php?option=com_content&task=view&id=67&Itemid=80 

INSTALLAZIONE COMPLETA ED EX NOVO DI UN SERVER PHP 4.x, APACHE 2.x E MYSQL 3.x SOTTO WINDOWS Vedi (**************)

Costruirsi un server web in locale (Vedi)

Apache e IIS sulla stessa macchina.
Supponiamo di avere una macchina con due ip (192.168.0.2, 192.168.0.3); in teoria dovrei poter fare girare due istanze di un mail server, per esempio, sulle stesse porte ma bindandoli su due IP diversi. Quando provo con IIS e Apache, non funziona mai.
Effettivamente, in linea teorica è possibile bindare IIS e Apache sulla stessa prota ma su IP differenti. In realtà però IIS adotta il "Socket pooling" tale che resta in ascolto su tutti gli IP anche quelli non bindati direttamente a un sito Web, per tale motivo Apache e IIS non possono girare sulla stessa porta anche se con IP differenti. In IIS5 è ancora possibile disabilitare il Socket Pooling utilizzando l'utility "adsutil.vbs", in IIS6 questo invece non ha nessun effetto, di fatto questa funzionalità viene implementata a livello di kernel in HTTP.sys e dovrebbe essere gestita tramite HTTPCFG.EXE. La knowledge base di Microsoft rispetto all'argomento è consultabile all'indirizzo http://support.microsoft.com/kb/238131
Attenzione: disabilitare il Socket Pooling conduce ad un decremento delle prestazioni.

DeveloperSide.NET Web-Server Suite (http://www.devside.net/) (OTTIMO *******)

Server Specifics -- std v1.14 (http://www.devside.net/web/server/free/download)

Server Specifics -- ssl v1.14s  (http://www.devside.net/web/server/free/download)

Reactor 1.x: http://www.reactorserver.com/ (OTTIMO *******)
Reactor Components:
+ Apache 2.0.52
+ MySQL 4.0.20
+ PHP 5.0.2 + PEAR
+ Perl 5.8.3 (mini)
+ Openssl 0.9.7e
+ mod_ssl 2.0.52
+ SQLite 2.8.14
+ Zend Optimizer 2.5.3 
+ PHPMyAdmin 2.6.0-pl3
+ PHP-Nuke 7.5 (No Mail() Hack Preinstalled)
+ Zina 0.10.28

Ottimo editor PHP: MPS PHP Design http://www.mpsoftware.dk/ ( http://www.mpsoftware.dk/phpdesigner.php )

A questo indirizzo, http://www.appservnetwork.com/, si può trovare una suite contenente i seguenti programmi
AppServ 2.4.0

Permette di creare un web server per testare le proprie pagine PHP e MYSQL.

Wamp
Wamp (Suite PHP e Mysql) http://thinkro.com/content/resources.php?view=wamp 
http://www.en.wampserver.com/download.php 
PHP5 Apache MySQL sur Windows : WAMP5
WAMP5 est un logiciel permettant d'installer l'ensemble PHP5 Apache et MySQL sur Windows; il dispose d'un gestionnaire de services permettant d'administrer ...
www.wampserver.com/

Apache 1.3.31

XAMPP - Crearsi un server domestico
http://www.apachefriends.org/en/xampp.html
Disponibile in 4 versioni: per Linux, Windows, Mac OS X e Solaris, comprendono:
Apache HTTPD 2.2.3
MySQL 5.0.27
PHP 5.2.0 + 4.4.4 + PEAR + Switch, MiniPerl 5.8.7
Openssl 0.9.8d
phpMyAdmin 2.9.1.1
XAMPP Control Panel 2.3
Webalizer 2.01-10
Mercury Mail Transport System für Win32 und NetWare Systems v4.01a
FileZilla FTP Server 0.9.20, SQLite 2.8.15
ADODB 4.93
Zend Optimizer 3.0.2
Insomma con XAMPP ci si può creare una postazione server praticamente professionale in 5 minuti, completamente gratis!
Esiste anche una versione portable da mettere su una normalissima chiavetta usb per utilizzarlo senza installazione (http://portableapps.com/apps/development/xampp)

Lamp Guida: http://php.html.it/guide/leggi/92/guida-lamp/

*** IL MIGLIORE ***
A questo indirizzo, http://www.wmcreation.it/index.php?action=wmservertools , si può trovare un'altra suite OTTIMA:
WMServer Tools è un utility che raccoglie: Apache - PHP - Perl - PHPMyAdmin - MySQL e WMServer SMTP (per testare l'invio delle e-mails in locale). Poichè è già tutto configurato, basta eseguire l'installazione per poter così gestire il tutto con estrema semplicità.
E' molto discreto, infatti al suo avvio si limita ad inserire un'icona sulla barra delle applicazioni, dove è possibile visualizzare l'avvio corretto di Apache e MySql tramite due spie di colore arancio (grigio = spento; rosso = errore).
Con un "popup menu" è possibile tramite:
- Setting - Cambiare la lingua e impostare le opzioni di avvio.
- Menu Editor - Gestire, tramite l'apposito editor, i collegamenti che sono presenti sul menu e i corrispondenti sottomenu, crearne nuovi, nonchè cambiare le icone.
- Check for Update - Controllare eventuali aggiornamenti.
- Add-ons - Controllare ed aggiungere nuove funzioni. (Default è installato WMServer SMTP che ti consente di testare l'invio di una e-mail in locale e WMLogs Reset) .
- Start Apache - Avviare Apache - Stop Apache - Terminare Apache
- Start MySql - Avviare MySql - Stop MySql - Terminare MySql

La V3.2 dispone di: Apache 2.0.52 - PHP 4.3.9 + Zend Opt. 2.5.5 - Perl 5.8.4 - MySQL 4.0.22 - phpMyAdmin-2.6.0-pl3
Per scaricarla: andare a questo indirizzo: http://www.wmcreation.it/download/software/ e selezionare la versione 1111wmservertools.exe

WMServer Tools CD ti consente di creare ed utilizzare un vero e proprio server su CD-Rom.
Selezionando semplicemente la cartella contentente il sito e quella del database, questa utility provvederà a creare in automatico, un CD-Rom autoavviante con incluso: Apache, PHP, Perl e MySQL.
In questo modo potrai far funzionare il tuo sito direttamente su CD e su qualsiasi PC senza l'obbligo di installare alcun componente aggiuntivo. 

Per chi vuole avvicinarsi al linguaggio di programmazione PHP, ed opera su piattaforma Windows, può installare il programma EasyPHP. Il programma crea un ambiente composto dai seguenti pacchetti: Apache (webserver), MySql (database), PHP (il linguaggio di programmazione) e PHPMyAdmin (interfaccia di gestione del database MySQL)
Questo pacchetto completo si può scaricare al seguente indirizzo:
http://www.easyphp.org

Apache Toolbox   
Descrizione: Apache Toolbox fornisce una installazione facile di Apache con SSL, PHP, ZendOptimizer, mod_auth_nds, mod_dynvhost, WebDAV, mod_fastcgi, mod_gzip, mod_layout, mod_throttle, mod_accessref, mod_roaming, mod_auth_sys, mod_bandwidth, mod_auth_ldap, mod_perl, openldap, e le ultime librerie GD con il supporto per il formato PNG. L'installazione e' ocmpletamente personalizzabile tramite dei semplici menu'. Tutti i moduli/file sono installati/compilati direttamente dai loro sorgenti.
 http://www.apachetoolbox.com/

PHP EasyWindows Installer   
Descrizione: Questo programma permette di installare in PWS o in IIS l'ultima versione di PHP (la 4.0.3). Sono disponibili all'interno della directory di installazione le istruzioni per Apache e altri Web server. Sono incluse le seguenti estensioni : GD, Interbase, Sybase, Informix, MSSQL7, Oracle, OCI8, IMAP, MySQL (integrato nel codice), CPDF, PDF, PGSQL, ZLib, LDAP, MHash, GNU GetText, CyberCash, Curl, DBM, Calendar (integrato nel codice), FDF, FilePro, XML, DOMXML, Sablot (XSL). Inoltre sono incluse due librerie OpenSource : PEAR 1.8 e ADODB Database Library 0.46. Il software e' stato testato nei seguenti OS : Windows 98, Windows NT, e Windows 2000.

http://php.weblogs.com/easywindows

PHPMyAdmin
Gestiamo i database con PhpMyAdmin
PhpMyAdmin è un tool in PHP per la gestione dei database. Consente, grazie all'utilizzo di un pannello di controllo molto intuitivo, di creare, eliminare, modificare e gestire al meglio i database MySQL; creare, modificare, cancellare intere tabelle o singoli record; fare un backup dei dati contenuti nel database, e visualizzare informazioni sul db.
Dopo aver scaricato il pacchetto, decomprimiamolo in una cartella, e modifichiamo il file di configurazione config.inc.php.
Una volta aperto, modifichiamo le seguenti righe di codice:
$cfg['Servers'][$i]['host']
Questa variabile corrisponde all'host a cui dovrà connettersi PhpMyAdmin per accedere al database. Sostituiamo host con l'indirizzo del nostro database(es. sql.vostronome.it)
$cfg['Servers'][$i]['port']
port invece va sostituito con la porta su cui lavora MySQL nella nostra macchina. Solitamente è la 3306
$cfg['Servers'][$i]['user']
L'username da utilizzare per connettersi al database
$cfg['Servers'][$i]['password']
La password da utilizzare per connettersi al database
$cfg['Servers'][$i]['controluser']
Nome utente che utilizzeremo per collegarci a PhpMyAdmin
$cfg['Servers'][$i]['controlpass']
Password che utilizzeremo per collegarci a PhpMyAdmin

Dopo aver completato la configurazione, accediamo a PhpMyAdmin tramite l'indirizzo www.vostronome.it/cartellaphpmyadmin/index.php, e iniziamo a lavorare con questo interessantissimo tool.

Cherokee
Cherokee is a flexible, very fast, lightweight Web server. It is implemented entirely in C, and has no dependencies beyond a standard C library. It is embeddable and extensible with plug-ins. It supports on-the-fly configuration by reading files or strings, TLS/SSL (via GNUTLS or OpenSSL), virtual hosts, authentication, cache friendly features, PHP, custom error management, and much more.
http://www.0x50.org/

VertrigoServ
VertrigoServ was developed to make available a highly professional and easily installable package of Apache, PHP5, MySQL4 and PhpMyAdmin for Windows platform. With a convenient all-in-one installer, all components are installed
in a single directory and can be used immediately after the installation
process has copleted. An uninstaller allows you to remove the VertrigoServ from
hard disc.
Version 1.19 contains:
* Apache 1.3.33
* PHP 5.0.5
* MySQL 4.1.14
* PhpMyAdmin 2.6.3-pl1
* ZendOptimizer 2.5.10
* SQLiteManager 1.1.1
http://vertrigo.sourceforge.net/

NetServer is a pack of servers for Windows NT/2000/2003/XP, controlled and configured by an easy to use interface designed for the project which will run in the systray. This includes Apache+PHP, MySql, Filezilla FTP Server, hMailServer and PHP scripts.
http://sourceforge.net/projects/netserver
http://netserver.hugosoft.net/
What is NetServer?
What can it do?
You want to host your own website?
You can´t afford hosting a site on somewhere else or you don't like the free hosting-sites?
You have a PC at home that maybe connected to the internet for 24/7 ?
You need a place to host or test your PHP-scripts?
Need a SSL secured web server?
Download NetServer and your PC will become a Web Server, Database Server, FTP Server, Mail Server in just 5 minutes. As easy as eating a pie.
And the best of all is that NetServer is free and open-source under the GNU/GPL.
Latest version - NetServer 01beta5 (build 3)
Server versions :
- Apache/2.0.54 (Win32)
- mod_perl/1.99_16
- Perl/v5.8.6
- PHP/4.4.0
- PHP/5.0.4
- mod_ssl/2.0.54
- OpenSSL/0.9.7g
- MySQL 4.1.14 - updated
- Filezilla FTP server 0.9.10a - updated
- hMailServer 4.1 build 136 - updated
Script versions :
- phpMyAdmin 2.6.4-pl1 - updated
- SquirrelMail 1.4.5

Uniform Server
http://www.uniformserver.com/
Documentazione: http://doc.uniformserver.com/


Links

PHP: http://www.php.net
Apache: http://www.apache.org
MySQL: http://www.mysql.com il database più popolare per internet
PHPMyadmin: http://www.phpmyadmin.net 
FireBird: http://firebird.sourceforge.net è un database proprietario di Interbase.
MiniSQL o mSQL: http://www.hughes.com.au caratteristica principale è l'efficienza.
PicoSQL: http://www.picosoft.it/picosql/ database sviluppato in Italia, con supporto completo del linguaggio SQL-92. Facilità d'uso e ridotte esigenze di memoria e CPU.
PostgreSQL: http://www.postgresql.ord è il DB con il maggior consumo di memoria, ma quello con maggior numero di funzioni. Quasi tutte le capacità SQL sono disponibili. Le prestazioni sono inferiori a quelle di MySQL
PHPEverywhere: http://phplens.com/phpeverywhere

(vedi anche php.ppt)

http://www.phpnews.it/index.php
http://www.apache3000.net/
 
http://www.phpitalia.net/                        
http://www.phpitalia.com/
http://www.latoserver.it/
http://www.totallyphp.co.uk/
http://www.tuttoinfo.it
http://www.myphp.it
http://www.php-power.it
http://www.phpcenter.it
http://www.phpmylinux.it
http://www.asp-php.net
http://www.hotscripts.com/
 
http://www.phpfreaks.com/
http://www.webdevindex.net/
http://www.webmasterpoint.org/              http://php.webmasterpoint.org/
http://www.sferascripts.com/
http://www.redangel.it/php/
http://www.onlyphp.com/
http://www.e107.org/
http://www.xoops.org/
http://www.postnuke.com/ (buono)
http://freephp.html.it/
http://forum.phpsoft.it/
http://www.php-proxima.com/site/modules.php?name=Proxima_XP  
http://www.freether.com   
http://www.mywebgeneration.com/ 
http://php.resourceindex.com/  (*************)
http://www.hostctnet.it/manuale-areariservata.php 
http://www.hackerjournal.it/ 
http://www.kel666.it 
http://punto-informatico.it/download/index.asp 
http://www.itportal.it/ 
http://guide.supereva.com/cgi-bin/indexscrivimi.chm?idcat=6231&start=0&step=20 
http://www.risorseweb.net/downloads.html 
http://www.freeopen.org/ 
http://www.webaiuto.it/ 
http://www.phpnoise.com/
http://www.hotscripts.com/
http://www.mrwebmaster.it/fareweb/php/
http://www.mrwebmaster.it/tutorial/php/elenco2.htm
http://www.mrwebmaster.it/script/php/elenco_cat.htm
http://www.mrwebmaster.it/
http://www.spacemarc.it
http://www.lorenza.it/
http://www.phpindex.com/
http://www.hotscripts.com/
http://www.morpheusweb.it
http://www.scriptforwebmaster.com/
http://www.webmaster-risorse.com
http://www.tuttophp.altervista.org/
http://www.phpbook.it/ (********)
http://www.php-scripts.com/
http://www.onlyphp.com/
http://www.php-free.de/
http://www.webscriptsdirectory.com/PHP/
http://www.scriptdownloads.com/
http://freephp.html.it/
http://www.mrwebmaster.it/
http://www.stadtaus.com/it/php_scripts/guestbook_script/
http://www.spacemarc.it/scriptphp/index.php

http://www.freesql.org
http://nemo89.altervista.org/php/index.php Nemus - PHPFree
http://www.phpitalia.net/
http://www.phpnukefordonkeys.com
http://www.phpfreaks.com
http://www.mmkit.com
http://www.sassidesign.it/ (*****)
http://www.scriptphp.net
http://studenti.scuole.bo.it/sistemi/webattivo/ 
http://www.phpnoise.com
http://www.scriptsearch.com/PHP/Scripts_and_Programs/ (******)
http://www.bigwebmaster.com/ (******)
http://www.devscripts.com/ (******)
Manuale e tutorial php: http://www.w3schools.com/php/
Tips e suggerimenti vari: http://www.thesitewizard.com/php/index.shtml
Help Desk Software http://www.opensourcehelpdesklist.com/
PHP http://it.wikibooks.org/wiki/PHP (**********)
Codice Facile (alcuni script in php e html/mysql/java): http://www.codicefacile.it
Moltissimi SCRIPTS: http://www.installall.net/browse (***********)

Tips: http://www.thesitewizard.com/php/index.shtml

Calendari
http://w100w.com/italian/php/calendars/
Utilities php
http://w100w.com/italian/php/
MySQL Aministrator
http://www.mysql.com/products/tools/administrator/
Borland Interbase 7.5
http://info.borland.com/devsupport/interbase/opensource/
PostgreSQL
http://www.postgresql.org
DB4Free
http://www.db4free.net
MySQL Migration Toolkit
http://dev.mysql.com/downloads/migration-toolkit/1.0.html
Maguma Open Studio
http://www.sourceforge.net/projects/openstudio/
http://www.maguma.com
Statistiche online
http://www.phpstats.net/
Mailing list (non necessita di database) ***************
http://www.ninjadesigns.co.uk/
Jask Calendar (non necessita di database) *************
http://www.hotscripts.com/listing/jax-calendar/

WebAdmin
Webadmin.php is a simple Web-based file manager.
Deutsch, Français, Italiano, Netherlands, Svenska, Español, Dansk, Türkçe, Čeština, русский язык, English
http://cker.name/webadmin/
net2ftp
http://www.net2ftp.com/

Knowledge Management/Document Management System (Archiviazione informatizzata)
http://sourceforge.net/directory/business-enterprise/knowledgemanagement/os:windows/freshness:recently-updated/

PHP AdminPanel
http://www.apphp.com/php-adminpanel/index.php

Open Source Help Desk List
http://www.opensourcehelpdesklist.com/ (multipiattaforma, asp e php)

Gestionali free
Gazie - Gestione Azienda
(******)
P.S. Richiede server web Apache, Mysql, PHP, FPDF
http://gazie.sourceforge.net/
GAL Gestione Aziendale Libera
http://gal.sourceforge.net/

News dal sito (php): http://freephp.html.it/script/lista.asp?idcat=13
http://www.free.imolanet.com/news.htm
http://www.scriptphp.net/news_sito.htm

http://www.helpcenterlive.com
Cercare su google: help desk (o helpdesk) php (assistenza tecnica)

PHPTicket
Gestione ticket di aiuto
PHP Ticket is an advanced ticketing system, written in PHP with a MySQL backend, includes user management through sessions, a search function and several other functions to simply ticket management. It can be hosted on any platform running PHP
http://sourceforge.net/projects/ticket/

RW:Script
http://www.rwscripts.com

Rad UpLoad Script
http://www.rwscripts.com/index.php?url=scripts.htm

RW::Download Version
4.0 lite
Web based install/upgrade
X
Template System with skin logic
X
Unlimited Base Categories
X
Download/Viewed Counter
X
File Linking
X
File Info Screen
X
User Upload
X
File Upload
X
Admin CP
X
Can access .htaccess protected folders
X
Multi Language Support
X
Basic Support
X
Free Script Upgrades
X
File Streaming
X
File type control
X
Language importing and exporting
X
Template importing and exporting
X

dBlog CMS è una piattaforma gratuita a codice aperto, progettata per la creazione e la gestione di un blog, interfaccia in italiano, semplice da utilizzare, veloce e pratica da installare.
Limitazioni: Link al produttore in ogni pagina
http://download.html.it/software/getit/2109/dblog/

FreeTpl Shop PHP Shopping Cart consente di effettuare il download di prodotti software con l'opzione di attivazione istantanea. Per questo potrebbe risultare molto utile alle software house che vendono i loro prodotti via Internet.
Può essere integrato in qualsiasi sistema che utilizza i template ed i tool di amministrazione. Consente di esercitare semplicemente le operazioni di vendita più avanzate come rassegne e valutazioni dei prodotti, meccanismi di sconti, sistemi per la spedizione ecc.
L'amministrazione è web-based: da qui è possibile gestire gli ordini, i prodotti, la lista degli utenti e le varie soluzioni di pagamento. Supporta i sistemi di pagamento più diffusi come Verisign, Paypal e Authorize.net.
È un freeware, dunque viene distribuito gratuitamente senza nessuna limitazione.
http://download.html.it/software/vedi/3259/freetpl-shop-php-shopping-cart/
http://www.freetpl.com/

PHPUnit creato da Sebastian Bergman che permette automaticamente, attraverso una serie di procedure automatizzate di analizzare il codice scritto alla caccia degli errori e dei bugs più frequenti.
http://sourceforge.net/projects/phpunit/

Script per password
http://freephp.html.it/programmatori/lista.asp?idcat=8

Servizi GRATUITI di web hosting con supporto PHP/SQL?
www.mycgiscripts.com
www.spaceports.com
www.3q.to
www.altervista.org

Fantastico DeLuxe (vedi cpanel)
http://www.bright-byte.com/fantastico.shtml
Fantastico De Luxe
is an amazing CPanel/PHP based Web application. It integrates with CPanel and gives you/your clients the ability to automagically install the following Open Source Applications
(Languages: Fantastico currently includes following language files: Dutch, English, Italian, Polish, Portuguese, Spanish)
All applications are latest versions and are updated regularly.

Blogs:
b2 (website)
b2evolution (website)
Nucleus (website)
pMachine Free (website)
WordPress (website)
WordPress è uno script PHP - MySQL che se installato nel vostro dominio, permette di gestire un blog elegante e professionale in maniera facile ed intuitiva. Sicuramente si tratta di un'ottima alternativa a Blogger o Splinder per coloro che possiedano uno spazio web che supporti il PHP e MySQL.
Link per il download: http://wordpress.org/download/
All'indirizzo http://wordpress.org/extend/themes/ sono scaricabili GRATUITAMENTE dei templates favolosi per il proprio blog.

Customer Support:
Crafty Syntax Live Help (website)
Help Center Live (website)
osTicket (website)
PHP Support Tickets (website)
Support Logic Helpdesk (website)
Support Services Manager (website)

E-Commerce:
CubeCart (website)
OS Commerce (website)
Zen_Cart (website)

Image Galleries:
4images Gallery (website)
Coppermine Photo Gallery (website)
Gallery (website)
deGallery (website)

Polls and Surveys:
Advanced Poll (website)
phpESP (website)
PHPSurveyor (website)

FAQ:
FAQMasterFlex (website)

Wiki:
PhpWiki (website)
TikiWiki (website)
MediaWifi (website)
Portals/CMS:
Drupal (website)
Geeklog (website)
Mambo Open Source (website)
PHP-Nuke (visit site)
phpWCMS (website)
phpWebSite (website)
Post-Nuke (visit site)
Siteframe (website)
Typo3 (website)
Xoops (website)

Discussion Boards:
Invision Board (website)
phpBB2 (website)
SMF (website)

Project Management:
PHProjekt (website)
dotProject (website)

Mailing List:
PHPlist (website)

Other Scripts:
Dew-NewPHPLinks (website)
Moodle (website)
Noah’s Classifieds (website)
Open-Realty (website)
phpAdsNew (website)
PHPauction (website)
phpCOIN (website)
phpFormGenerator (website)
phpLinks (website)
WebCalendar (website)

Guestbooks:
ViPER Guestbook (website)

da: http://www.opensourcecms.com/

e-commerce

  • Phpshop
    Phpshop è un applicazione di e-commerce sviluppata in php. E' rilasciata sotto la GNU General Public License. Il primo proposito di phpshop è quello di fornire un semplice carrello facile da personalizzare per ogni esigenza. Phpshop ha meno opzioni di altre applicazioni di e-commerce, ma è generalmente più semplice da personalizzare. Tutto cio che è richiesto per personalizzare phpshop sono conoscenze basilari di HTML, PHP e SQL. (dal sito phpshop.org)
  • osCommerce
    osCommerce is an online shop e-commerce solution that offers a wide range of out-of-the-box features that allows online stores to be setup fairly quickly with ease, and is available for free as an Open Source based solution released under the GNU General Public License.
    osCommerce was started in March 2000 and has since matured to a solution that is currently powering 10,830 registered live shops around the world.
  • Zen Cart
    Zen Cart "rappresenta davvero l Arte dell' E-commerce" un sistema di e-comerce open source, gratuito, di notevole facilità d'uso, che permetete di avviare subito la propria attività online.
    Il software viene sviluppato da un affiatato team di esperti: negozianti, programmatori, designer e consulenti convinti che l E-commerce possa e debba assumere una formula semplice ma accattivante.
    Certe "soluzioni" fin ora proposte più che rispondere alle esigenze dell utenza appaiono esercizi di programmazione di grande complessità ... Invece Zen Cart pone in primo piano sia le aspettative del negoziante che del cliente. Certe altre "soluzioni" sono basate su programmi praticamente inutilizzabili se non si è super-esperti nelle Tecnologie dell Informazione.
    (dal sito zencart-italia.it)

Forum

  • PhpBB3
    phpBB è una tra le più potenti bulletin board Open Source su web,completamente modificabile anche da utenti non molto esperti. phpBB haun interfaccia piacevole, un potente pannello di inistrazione, e utilissime FAQ che ne facilitano l uso. phpBB sfrutta al meglio il linguaggio PHP e l utilizzo di database come MySQL, MS-SQL, PostgreSQL o Access/ODBC, phpBB è la soluzione migliore per creare comunità web gratuitamente.
    La versione 3 è molto più snella e funzionale ha comodi link in JS che fanno scomparire i menu quando non servono e anche per quel che riguarda la sicurezza è più curata.
    Per accedere alla demo dell' amministrazione dovete infatti prima loggarvi come utenti e poi, utilizzando il link in fondo alla pagina, loggarvi di nuovo ed entrare nell area dell'amministrazione.
  • PunBB
    PunBB è un forum di discussione molto leggero e veloce. Rilascito con licenza GNU General Public License. I suoi obiettivi primairi sono di essere più veloce, piccolo e meno pesante graficamente di altre piattaforme di discussione.
    PunBB ha meno caratteristiche di altri forum, ma è molto più veloce, semanticamente corretto sullo standard XHTML
  • W-Agora
    W-Agorà risulta molto versatile, dando l opportunità di creare più siti che a loro volta contengono un numero variabile di forum. Questo consente la costruzione e la più facile gestione di un servizio web per discussioni on line.
    Può essere usato anche come piattaforma di collaborazione data la possibilità di caricare file insieme ai post...
  • Simple Machines
    Simple Machines Forum - è un software che ti permette di creare la tua comunità online in pochi minuti. Il suo potente template engine permette di configurare completamente il lay-out della tua message board Con le sua uniche funzioni SSI - (Server Side Includes) puoi far interagire il tuo forum e il tuo sito internet l uno con l altro. SMF è scritto in PHP e usa MySQL come database. E progettato per offrire tutte le caratteristiche di cui hai bisogno avendo un impatto minimo per le risorse del server. SMF è la nuova generazione di software per forum e rimarra sempre completamente libero! (libremente tradotto da simplemachines.org)
  • XMB Forum
    Forum sviluppato in PHP - MySql , rilasciato con licenza GPL. Questo script permete di gestire un forum nel migliore dei modi avendo tutto le caratteristiche per gestire una grande comunità di utenti

Wiki

  • PM Wiki
    PM Wiki è un gestore di siti wiki, con molte opzioni per la autenticazione e la protezione delle pagine e per la modifica della struttura dei contenuti
  • Wikepage
    Se avete deciso di installare un sistema wiki per creare il vostro sito web completo di blog e feed rss , "wikepage" potrebbe essere la soluzione giusta. Anche perché è una soluzione flat-file cioè che non necessita di database per immagazzinare le informazioni. Inoltre permette sia la costruzione di siti web personali (modalità protetta da password) sia di siti web di comunità wiki (modalità aperta a tutti). La demo su "CMSOpenSource.it" è per il momento in versione inglese, nonostante lo script sia predisposto per l internazionalizzazione, data la mancanza di disponiblità del pacchetto in italiano.
  • QwikiWiki
    Qwiki Wiki è un sistema di creazione di un wiki completo con il minimo sforzo in termini di risorse di installazione. Non necessita di un database e richiede solamente un web server con php installato. Il peso dell installazione è minore di 500Kb.

Blog

  • sNews 14
    Questo blog engine è molto semplice e veloce, è strutturato in un solo file facilmente personalizzabile tutta l impaginazione è basata sui css
  • Wordpress
    Wordpress è il più famoso e utilizzato CMS per la gestione di blog. I suoi sviluppatori lo definiscono "lo stato dell arte" nel campo del blog e del personal publishing, unapiattaforma che non tralascia assolutamente l estetica, web standard e usabilità.
    L'istallazione di base è veramente completa, editor WYSYWYG, upload di immagini, facilità di configurazione e personalizzazione.
    Wordpress grazie anche all enorme disponibilità di plugin e di temi stà diventando lo standard nel campo del blog e non solo.
  • Textpattern
    Textpattern è un CMS molto semplice e funzionale. Ideale per amministrare un blog, la sua facilità d uso non impedisce di utilizzarlo per creare siti più complessi.
    Impaginato in XHTML 1.0 Transitional è validato W3C permette di gestire il layout dall amministrazione, ha una ottima possibilità di espansione grazie ai numerosi plugin e di personalizzazione tramite ben 98 differenti template liberamente scaricabili
  • microBlog
    In cerca di un blog veloce da installare e intuitivo nell utilizzo? Che comprenda il set minimo di opzioni per mettere su un blog in pochi minuti? microBlog si rivela non tanto "micro" quanto ad utilità...
  • Simple Php Blog
    Simple Php Blog è un semplicissimo blog in php, che non richiede la presenza di Database.
    Installazione e configurazione sono veloci e semplici quanto la gestione dei contenuti, tutto ciò non va a discapito delle funzionalità che non hanno nulla da invidiare ai più famosi script per l amministrazione di blog.

E-learning

  • Docebo
    Docebo LMS
    Dopo Spaghettilearning, il gruppo offre un LMS - Learning Management System - per la formazione online che si distingue per la leggerezza e la robustezza, con interessanti prestazioni ed una grafica più attraente. L installazione è semplificata, inoltre è possibile configurare numerose impostazioni dei vari percorsi. Si può ipotizzarne un utilizzo a livello di scuola secondaria, anche per gestire attività di sportello.
    Demo d uso e assistenza online.
    (Non tutte le voci della griglia si applicano).
  • ATutor
    ATutor è un Software Open Source dedicato all E-Learning. I sui sviluppatori lo definiscono un Learning Content Management System (LCMS) avendo in mente i criteri dell accesibilità e della adttabilità. Atutor si istalla in fochi minuti e utilizza un sistam di templates per gestire l interfaccia grafica, dando modo sia di dare al CMS facilemnte un nuovo look si di estenderne le funzioni con uno dei tanti moduli disponibili per il download.

Gallerie

  • Coppermine Photo Gallery
    Coppermine è uno script per gestire una galleria di immagini basata sul web. Scritto in PHP usando GD o ImageMagick come libreria di immagini con undatabase MySQL come backend.
    Coppermine è un free software che potete scaricare e installare sui vostri server e può essere facilmente integrato con i puù famosi CMS: Invision Power Board, Mambo, MyBB, phpBB 2, Phorum, PunBB, SMF, vBulletin, XMB, Xoops2, ecc..
  • Plogger
    Ploggerb è un sistema di creazione di gallerie forografiche. Supporta più album suddivisi in categorie.
  • WEBalbum
    WEBalbum è una galleria virtuale. WEBalbum rende possibile e facile pubblicare le tue foto su internet.
    Quello di cui c è bisogno sono solo un paio di click del mouse per aggiungere una o molte foto. Sarai tu a determinare chi avrà i diritti di vedere le tue foto o le tue gallerie. Ogni utente che visiterà il tuo sito puo dare un voto alle foto aggiungere commenti, o le proprie fotografie.
    Tutto dipenderà dai permessi che vorrai dare agli utenti
    (liberamente tradotto da web-album.org)
  • Gallery2
    Gallery è una applicazione open source per la condivisione di fotografie di nuova generazione. La gestione dellegallerie è molto semplice così come l istallazione dello script, che segue una procedura molto dettagliata e facile da seguire.
    Principali caratteristiche:
    • Facilità di creare gallerie fotografiche
    • User/photo amministrazione e modifica
    • Sitama di permessi molto evoluto
    • Layout completamente configurabile
    • Progettazione modulare
    • sistema di upload drag e drop
    • ...e altro.

    Rilasciata sotto licenza GPL

Portali-CMS

  • Drupal
    Drupal è un CMS che sta riscuotendo molto successo fra gli utilizzatori e sviluppatori di software Open Source. A prima vista, appena installato, appare scarno e difficile da configurare, essendo sprovvisto di una sfarzosa interfaccia di amministrazione propria dei più diffusi CMS (vedi joomla).Ma sotto questa semplicità apparente, si nasconde tutta la sua potenza.
    Drupal è a metà strada tra un CMS ed un framework, risultando molto flessibile per quello che riguarda la personalizzazione delle funzioni, la creazione di nuovi moduli e la gestione delle informazioni.
    L'amministrazione dei contenuti in Drupal è basata su una logica semantica, tanto cara al web 2.0, in cui ogni contenuto è considerato un nodo all'interno di una rete di informazioni organizzate in categorie o vocabolari semantici.
    Se a prima vista, per chi è abituato a pensare ad una struttura di contenuti gerarchica, questa logica può sembrare ostica per la gestione di un sito, in realtà quando si vuole amministrare una grande quantità di contenuti, cercando di richiamali da più parti del sito a seconda del contesto, questo meccanismo si rivela un'arma vincente.
    La struttura del codice di Drupal, ben si adatta a questa logica, il fatto di essere realizzato come un framework rendende possibile richiamare ogni funzione del core direttamente dai contenuti o dai cosddetti blocchi di contenuto permettendo una elasticità impressionanate nella gestione dell'informazione.
    Drupal ha alle spalle una comunità estremamente laboriosa e prolifica, sul sito ufficale sono presenti numerose guide e un API molto dettagliata, inoltre il numero di Moduli già realizzati per la personalizzazione e l'ottimizzazione è davvero impressionante.
  • CMS Made Simple
    CMS Made Simple, è un CMS molto semplice ma veramente potente.
    La sua caratteristica princiale è quella di avere una organizzazione dei contenuti immediata ed efficacie, una struttura ad albero, in cui si possono organizzare le informazioni facilmente in categorie e sottocategorie con l'ausilio di freccie o di un comodo drang & drop ajax.
    Ogni contenuto ha prevede i campi opzionali per inserire i meta tag e tutti gli attributi e le chiavi per l'accessibilità.
    La comunità di supporto di CMS Made Simple, è molto attiva, le release del software si susseguono con alta frequenza e il forum di supporto e ben frequentato (con una sezione in italiano) e le wiki, presenti anche in italiano, coprono tutti i principali moduli del CMS.
    I template sono immagazinati nel database, ma possono anche essere utilizzati files sul server, sono scritti utilizzando il template engine Smarty, che permette una flessibilità prodigiosa nel trattare i presentare i dati.
    Molto comodo è il modulo Module Manager che permette di installare qualsiasi modulo si voglia dalla interfaccia di amministrazione senza dover passare per download e ftp.
    La cosa più comoda di questo CMS è la possibilità di richiamare ogni modulo o funzione (tag) direttamente nel corpo del contenuto utilizzando la sintassi smarty, se ad esempio volessi richiamere qui sotto 5 news della categoria cmsnews dovrei scrivere:
    {news number='5' category='cmsnews' morelink='leggi..' }
    CMS Made Simple è CMS decisamente interessante che permette anche a gli sviluppatori meno smaliziati di creare siti molto elaborati.
  • Xoops
    XOOPS, un CMS per tutti! Se stai cercando uno script leggero, flessibile e potente per creare un tuo portale da pubblicare, o da inserire in una intranet aziendale, sei nel posto giusto. XOOPS è un applicazione web facile da usare, non richiede talenti particolari e nemmeno conoscenze di programmazione. Basta avere una connessione a internet, le conoscenze di base del PC e di applicazioni per la gestione del testo, tipo Word o blocco note e un po di buona volontà. dal sito
    www.xoopsitalia.org
  • e107
    e107 è un sistema di gestione dei contenuti scritto in PHP e che si avvale del popolare databse MySQL per l amministrazione dei contenuti. E completamente libero, totalmente modificabile e in costante evoluzione.
    Rilasciato con licenza GPL.
  • Php Fusion
    PHP-Fusion e` un open-source content management system (CMS) molto leggero scritto in PHP. Utilizza un database mySQL per memorizzare i contenuti del sito e include un semplice e completo sistema di amministrazione. PHP-Fusion include tutte le funzioni comuni che ti aspetti di trovare in un qualsiasi CMS.
    PHP-Fusion e` rilasciato sotto i termini e le condizioni della seconda versione della GNU General Public License. Per maggiori informazioni visita www.gnu.org o fai riferimento al documento gpl.txt contenuto in questo pacchetto. Puoi alterare il codice in qualunque maniera tu la ritenga piu` opportuna e ridistribuirlo cosi` come e` o con le proprie modifiche. Ti saremo gradi se manterrai la dicitura "Powered by PHP-Fusion" nel footer delle pagine. Pensiamo che questo sia il minimo se consideri le centiniaia di ore di lavoro nello sviluppo di questo progetto. Comunque, se vuoi rimuovere il copyright nel footer, sei fortemente invitato a fare una donazione tramite Paypal al progetto.
  • Joomla
    Se avete letto qualche cosa riguardo i Content Management Systems (CMS), probabilmente conoscerete almeno tre cose: i CMS sono il modo più stimolante di fare affari, i CMS posso essere realmente, intendo realmente, complicati e i portali di ultima generazione sono assolutamente difficili da utilizzare ed economicamente troppo costosi.
    Joomla! è costruito proprio per cambiare tutto questo ... Joomla è differente dai normali software di gestione per portali. Per iniziare, Joomla non è complicato. Joomla è stato sviluppato per le masse. E autorizzato e rilasciato liberamente sotto licenza GNU/GPL, semplice da installare ed amministrare e molto affidabile. Joomla non costringe l utente alla conoscenza di linguaggi di programmazione per la creazione di pagine dinamiche, in quanto troverà tutti gli strumenti per operare in estrema semplicità.
  • Nucleus
    CMS con XHTML e CSS validi. Supporta le funzioni di base di un CMS ed ha una struttura simile ai blog.

Groupware

  • ACollab
    ACollab è una piattaforma di collaborazione a distanza integrabile con ATutor, un sistema di e-learning
  • phpGroupWare
    phpGroupWare (conosciuto precedentemente come webdistro) è una applicazione multi utente per il lavoro di gruppo, scritta in PHP.
    Essa fornisce su piattaforma web un calendario, lista delle cose da fare, rubrica, email, titoli di news e un file manager. Il calendario supporta gli eventi periodici. Il sistema email supporta la grafica e i file allegati.
    Tutto il sistema supporta le preferenze degli utenti, i temi, il controllo degli accessi, il supporto multi lingua, una API avanzata e i gruppi di utenti.
    N.B: l area di amministrazione e di utente hanno la stessa interfaccia di immissione delle credenziali di accesso. Per l area lato utente ("pubblica")
    inserisci nome utente "demo", password "demo". Inoltre nella demo, per motivi di sicurezza, sono disattivate le funzioni email e cambio di preferenze nei profili utente e amministratore

 

Blogs
Nucleus
pMachine Free
WordPress
Nucleus
http://nucleuscms.org/ 
A powerful blog script featuring multiple blogs, multiple authors, drafts and future posts, bookmarklets.
Un potente blog caratterizzato da blog multipli, autori multipli, bozze per invii futuri, bookmarklets.
pMachine Free
This is a features limited version of pMachinePro.
Questa e' una versione limitata di pMachinePro
Homepage: http://www.pmachine.com/ 
WordPress
WordPress is a personal publishing tool with focus on aesthetics and featuring cross-blog tool, password protected posts, importing, typographical niceties, multiple authors, bookmarklets.
WordPress e' un sistema di pubblicazione personale con molta cura dell'estetica e caratterizzato da un tool cross-blog, post protetti da password, importazione, accortezze tipografiche, autori multipli, bookmarklets.
Homepage: http://wordpress.org/ 
Content Management
Geeklog
Joomla
Mambo Open Source
phpWCMS
phpWebSite
Post-Nuke
Siteframe
OpenCommercio
MyScrapbook
Geeklog
A portal system with a wide range of modules.
Un portal system con un gran numero di modules.
Homepage: http://www.geeklog.net/ 
Joomla
Joomla! is one of the most powerful Open Source Content Management Systems on the planet. It is used all over the world for everything from simple websites to complex corporate applications. Joomla! is easy to install, simple to manage, and reliable.
Homepage: http://www.joomla.org/ 
Tutorial su Joomla
vedi
Mambo Open Source
A professional level yet easy to use Content Management System featuring inline WYSIWYG content editors, newsfeeds, syndicated news, banners, mailing users, links manager, statistics, content archiving, date based content, 20 languages, modules and components.
Un Content Management System professionale e tuttavia facile da utilizzare con un sistema WYSIWYG per la gestione delle notizie, newsfeeds, syndicated news, banners, mailing users, gestione links, statistiche, content archiving, date based content, 20 linguaggi e altri moduli e componenti.
Homepage: http://mamboserver.com/ 
phpWCMS
phpWCMS is perfect for professional, public and private users. It is very easy to learn and gives you the flexibility to separate layout and content. Lots of powerful but simple implemented features assists publishers and web developers too.
phpWCMS e' perfetto per gli utenti pubblici, privati e per i professionisti. E' molto facile da imparare e molto semplice da modificare e permette facilmente di modificare l'impostazione grafica. Le tante ma semplici features permettono di utilizzare velocemente il sistema sia agli editori che agli sviluppatori.
Homepage: http://www.phpwcms.de/  
phpWebSite
Very powerful Content Management System with document manager, announcements, menu manager, photo album, block maker, FAQ, web pages maker, polls, information categorizer, calendar, link manager, form generator.
Un Content Management molto potente con la gestione dei documenti, annunci, menu manager, foto album, creazione blocchi aggiuntivi, FAQ, creazione pagine web, sondaggi, information categorizer, calendario, gestione link, form generator.
Homepage: http://phpwebsite.appstate.edu/  
Post-Nuke
A Content Management System with focus on flexibility and security. A big variety of modules and blocks makes this CMS an allround tool.
Un Content Management orientato alla flessibilita' ed alla sicurezza. Una grande varieta' di moduli e blocchi rende questo CMS un sistema davvero completo.
Homepage: http://www.postnuke.com/  
Siteframe
A straightforward content-management system designed for rapid deployment of community-based websites. Nice-looking templates, oriented toward document-sharing, clean interface.
Un Content Management progettato per realizzare velocemente siti basati sulla comunita'. Temi molto gradevoli, orientato alla condivisione dei documenti, interfaccia pulita.
Homepage: http://siteframe.org/ 
MyScrapbook 3.1
Un sito personale elegante e funzionale creato in pochi minuti! Con MyScrapbook è come scrivere sulle pagine di un quaderno: si possono inserire testi, immagini, links, il tutto suddiviso in capitoli e sottocapitoli come in un libro.
La grafica è piacevole, e una volta tanto si può leggere una intera pagina WEB senza stancarsi, proprio come se si avesse tra le mani un vero libro.
Sito Ufficiale: http://sourceforge.net/projects/myscrapbook/
Customer Relationship
Crafty Syntax Live Help
Help Center Live
osTicket
PHP Support Tickets
Support Logic Helpdesk
Support Services Manager
Crafty Syntax Live Help
A Live Help chat system featuring monitor your visitors, proactively open a chat session, multiple chat sessions, referer tracking, page view tracking, multiple operators, canned responses/images/URLs, multiple departments each with different icons, leave a message.
Il sistema di chat Live Help permette di monitorari i tuoi visitatori, aprire automaticamente una nuova sessione di chat, avere piu' sessioni di chat contemporanee, tracking dei referer, tracking delle pagine viste, operatori multipli, messaggi/immagini/URLs predefiniti, piu' aree con iconne diverse, modulo 'lascia un messaggio' quando l'operatore non e' disponibile.
Homepage: http://www.craftysyntax.com/ 
Help Center Live
Very powerful all-in-one help center including Live Help, Support Tickets and FAQ. Features include unlimited operators/departments, monitor visitors, initiate chat, collect visitor's information, track visitor's footprint, autosave chat transcripts, canned messages, leave a message, auto-assign tickets to operators, unlimited FAQ topics.
Un help center all-in-one davvero potente che include Live Help, Support Tickets e FAQ. Tra le caratteristiche ci sono illimitati operatori/departimenti, monitor dei visitatori, tracciamento dei visitatore, salvataggio automatico del chat transcripts, canned message, leave a message, sistema di assegnamento automatico dei tickets agli operatori, illimitate categorie per le FAQ.
Homepage: http://www.helpcenterlive.com/ 
osTicket
A Support Tickets system featuring email piping, pop3 login, unlimited email addresses, admin/staff/user panels, avoid autoresponder loops, limit maximun tickets user can have opened, accept attachments and limit size, pager alerts for admin.
Un Support Tickets system caratterizzato da email piping, pop3 login, illimitati indirizzi email, pannello admin/staff/user, sistema per il blocco dei cicli degli autorisponditori, limite massimo di ticket che un utente puo' avere aperti, accetta allegati con la possibilita' di stabilire le dimensioni massime, sistema di alert per l'amministratore.
Homepage: http://www.osticket.com/server/  
PHP Support Tickets
A simple, one-admin Support Tickets system featuring self-registering, emailing to admin, attachments.
Un semplice Support Tickets system per un solo amminsitratore caratterizzato dalla possibilita' di iscrizione automatica, email dei messaggi all'amminsitratore, allegati.
Homepage: http://www.phpsupporttickets.com/ 
Support Logic Helpdesk
A Support Tickets system featuring multiple email addresses, admin/staff/user panels, canned responses, HTML tags support, email limit on a per user/day basis, attachments.
Un Support Tickets system caratterizzato da indirizzi email multipli, pannello admin/staff/user, supporto per tag HTML, limite email per utente/giorno, allegati.
Homepage: http://www.support-logic.com/index.php 
Support Services Manager
Homepage: http://www.sheddnet.net/  
Discussion Boards
SMF
SMF
Elegant. Effective. Powerful. Free. SMF is all of the above. SMF is a next-generation community software package and is jam-packed with features, while at the same time having a minimal impact on resources.
Elegant. Effective. Powerful. Free. SMF is all of the above. SMF is a next-generation community software package and is jam-packed with features, while at the same time having a minimal impact on resources.
Homepage: http://www.simplemachines.org/  
E-Commerce
CubeCart
OS Commerce
Zen Cart
CubeCart
An easy to use yet powerful shopping cart featuring unlimited categories and products, multiple payment gateways, downloadable products. The design is very easy to modify.
Un carrello della spesa facile da utilizzare caratterizzato da illimitate categorie e prodotti, gateway per il pagamento multipli, prodotti scaricabili (download di software). Il design e' davvero facile da modificare.
Homepage: http://www.cubecart.com/ 
OS Commerce
A power-user shopping cart with a big variety of modules and support of almost every payment gateway. A big developers community is ready to offer custom solutions depending on your needs.
Un sistema di ecommerce con una grande quantita' di moduli disponibili ed il supporto per la quasi totalita' dei gateway di pagamento esistenti. Una comunita' di sviluppatori molto grande e' pronta ad offrire soluzione personalizzate del pacchetto su ordinazione.
Homepage: http://oscommerce.com/  

OpenCommercio 2.2
OpenCommercio è il sistema italiano di e-commerce basato su OsCommerce. Con tutte le pagine tradotte in lingua italiana compreso il pannello di amministrazione, è ampiamente configurabile sia per l'inserimento di un numero illimitato di articoli, sia riguardo le offerte, le categorie, la gestione clienti e ordini. Un vero negozio virtuale dove proporre in vendita i propri prodotti.
Sito ufficiale:
http://www.opencommercio.com/

Zen Cart 
Zen Cart truly is the art of e-commerce; a free, user-friendly, open source shopping cart system. The software is being developed by group of like-minded shop owners, programmers, designers, and consultants that think e-commerce could be and should be done differently.
Homepage: http://www.zen-cart.com/  - http://www.zencart-italia.it/
NOPCommerce (ASP)
nopCommerce is an open source e-commerce solution that contains both a catalog frontend and an administration tool backend. nopCommerce is a fully customizable shopping cart. It's stable and highly usable. From downloads to documentation, nopCommerce.com offers a comprehensive base of information, resources, and support to the nopCommerce community. nopCommerce is a fully customizable shopping cart. It's stable and highly usable. nopCommerce is an open source e-commerce solution that is ASP.NET 4.0 based with a MS SQL 2005 (or higher) backend database. Our easy-to-use shopping cart solution is uniquely suited for merchants that have outgrown existing systems, and may be hosted with your current web host or our hosting partners. It has everything you need to get started in selling physical and digital goods over the internet. nopCommerce offers unprecedented flexibility and control. Since it is open-source, nopCommerce’s source code is available free for download.
http://www.nopcommerce.com
F.A.Q.
FAQMasterFlex
FAQMasterFlex
Unlimited categories/questions/answers, web-based administration.
Illimitate categorie/domande/risposte, con amministrazione web-based.
Homepage: http://www.technetguru.net/design/faqmasterflex.php  
Guestbooks
ViPER Guestbook
ViPER Guestbook
The ViPER Guestbook is a high end guestbook script that is versatile, reliable, very comfortable and easy to use. The perfect choice for the ambitious webmaster !
Homepage: http://www.vipergb.de.vu/  
Image Galleries
4Images Gallery
4Images Gallery
An Image Gallery system featuring unlimited categories/subcategories, web-based and FTP images upload, auto-thumbnails, comments, send a picture, rate a picture, random pictures, extensive administration panel.
Una Galleria di immagini caratterizzata da illimitate categorie/sottocategorie, upload delle immagini via web o FTP, miniature automatiche, commenti, invio di foto, votazione delle immagini, immagini random, vasto pannello di controllo.
Homepage: http://www.4homepages.de/ 
Coppermine Photo Gallery
An Image Gallery system featuring categories and albums, thumbnails and intermediate size pics, search feature, new and random pictures, user management (private galleries, groups), user comments, e-cards feature, slideshow viewer.
Una Galleria di immagini caratterizzata da categorie ed album, miniature, ricerca interna, nuove immagini random, gestione degli utenti (gallerie private, gruppi), commenti degli utenti, sistema e-cards, visualizzatore di slideshow.
Homepage: http://coppermine.sourceforge.net/  
Mailing Lists
PHPlist
PHPlist
A powerful mailing list featuring multiple mailing lists and attachments.
Un potente sistema per la gestione delle mailing list caratterizato da liste multiple e possibilita' di inviare allegati.
Homepage: http://www.tincan.co.uk/  (vari scripts)
Polls and Surveys
Advanced Poll
phpESP
PHPSurveyor
Advanced Poll
A highly windows-inspired poll script.
Un avanzato "windows-inspired" sistema di sondaggio.
Homepage: http://www.proxy2.de/scripts.php  (vari scripts)
phpESP
PhpESP is an effective, capable, web-based survey application that enables businesses to create complex and advanced surveys, view results in real time, and carry out advanced analysis.
PhpESP e' un'applicazione web-based efficace di indagine che permette di generare indagini complesse ed avanzate, di osservare i risultati in tempo reale e di effettuare analisi avanzate.
Homepage: http://phpesp.sourceforge.net/  
PHPSurveyor
Develop, publish and collect responses to surveys. Display surveys as single questions, group by group or all in one page or use a dataentry system for administration of paper-based versions of the survey. PHP Surveyor can produce 'branching' surveys (set conditions on whether individual questions will display), can vary the look and feel of your survey through a templating system, and can provide basic statistical analysis of your survey results.
Sviluppi, pubblichi e raccogli le risposte ai sondaggi. Puoi visualizzare i sondaggi come singole domande, come gruppi di domande e puoi usare un sistema dataentry per la gestione dei sondaggi. Tramite PHP puoi velocemente produrre le indagini 'ramificate'(condizioni d'impostazione sopra se le diverse domande saranno visualizzate), puoi variare il template del sondaggio e visualizzare l'analisi statistica di base dati i risultati del sondaggio.
Homepage: http://phpsurveyor.sourceforge.net/  - http://www.phpsurveyor.org/
Project Management
dotProject
PHProjekt
dotProject
Project Management featuring companies, projects, tasks (with Gantt charts), forums, files, calendar, contacts, tickets/helpdesk, language support, user/module permissions, themes.
Gestione di progetti - Project Management - caratterizzato da aziende, progetti, tasks (con diagrammi di Gantt), forum, file, calendario, contatti, ticket/helpdesk, multilingua, gestione permessi per utenti/moduli, temi.
Homepage: http://www.dotproject.net/  
PHProjekt
Project Management featuring optional group system, privileges, calendar, contacts, time card, projects, chat, forum, request tracker, mail client, files, notes, bookmarks, to-do list, reminder, voting, language support.
Gestione di progetti - Project Management - caratterizzato da sistema facoltativo dei gruppi, privilegi, calendario, contatti, scheda di lavorazione con i tempi, progetti, chat, forum, tracker delle richieste, client email, file, note, segnalibri, lista delle cosa da fare, appunti, sistema di votazione, multilingua.
Homepage: http://www.phprojekt.com/  
Site Builders
Templates Express
Templates Express
Use Templates Express to install static templates to your website. You will need to use FTP and edit the html files, replacing the default text with your own text. Standard information like title, name, address and similar will be collected during installation and placed into the installed template in the appropriate locations.
http://sohotemplates.com/ 
Wiki
PhpWiki
PhpWiki
PhpWiki is a web site where anyone can edit the pages through an HTML form. Linking is done automatically on the server side; all pages are stored in a database.
Homepage: http://phpwiki.sourceforge.net/  
Other Scripts
Dew-NewPHPLinks
Dokeos
Moodle
Noahs Classifieds
Open-Realty
phpAdsNew
PHPauction
phpFormGenerator
Dew-NewPHPLinks
A Link Directory featuring categories, reviews, popular links, new links, links approval.
Homepagehttp://www.dew-code.com/ 
Dokeos
Dokeos è una piattaforma, open source e gratuita, per la creazione di corsi a distanza, fruibili attraverso il web con il semplice utilizzo di un browser.
Tra le varie funzioni offerte dalla piattaforma, ricordiamo solamente la possibilità di creare e pubblicare percorsi e materiali didattici, gestire impegni e gruppi di alunni, comunicare e interagire con gli studenti stessi sia in modalità asincrona (e-mail e forum integrati) che sincrona (chat).
Homepage:
http://www.dokeos.com/download.php
Moodle
A course management system designed to help educators create quality online courses. Available in 34 languages and features a WYSIWYG HTML editor. The teacher has full control over all settings for a course. There is a flexible array of course activities (Forums, Journals, Quizzes, Resources, Choices, Surveys, Assignments, Chats, Workshops), user logging and tracking, mail integration and much more.
Un sistema di elearning - Course Management System - progettato per aiutare gli educatori a creare corsi online di qualita'. Disponibile in 34 lingue, caratterizzato da un editor HTML WYSIWYG, l'insegnante ha il controlo completo di tutti i settaggi del corso, gestione flessibile delle attivita' del corso (Forum, Pubblicazioni, Quiz, Risorse, Scelte, Indagini, Assegnazioni, Chat, Workshop), tracciamento e logging degli alunni, integrazione con email e molto altro.
Homepage: http://moodle.org/  
Noahs Classifieds
A classifieds system featuring categories and subcategories in unlimited depth, image upload for categories and classifieds, variable fields per categories, customizable email notifications, locking categories, classifieds approval, auto-thumbnail generation, classifieds management by user, send classified to a friend.
Un classifieds system caratterizzato da illimitate categorie e sottocategorie, upload di immagini per le categorie e per i classifieds, campi variabili per le categorie, notifiche email perosnalizzabili, blocco categorie, approvazione dei classifieds, generazione miniature in automatico, gestione dell'utente dei classifieds, invia un classified ad un amico.
Homepage: http://classifieds.phpoutsourcing.com/  
Open-Realty
Real Estate listing system featuring attachments, flexible search, template system, Yahoo Maps interface.
Homepage: http://www.open-realty.org/  
phpAdsNew
A highly professional complete ad server featuring different types of ads, display based on keywords, zones, hour of the day, day of the week, extensive statistics, client statistics.
Homepage: http://phpadsnew.com/  
PHPauction
The GPL version of PHPauction featuring email notification of bids, attachments, reserve price, minimum bids, standard and dutch auctions, bid history, send auction to a friend, highest bids, auctions ending soon.
La versione di GPL di PHPauction caratterizzata dalla notifica via email delle offerte, gestione allegati, prezzo di riserva, aste di diverso tipo, offerta minima, storia di un'offerta, invia l'asta ad un amico, le offerte più alte, aste che si concludono presto.
Homepage: http://www.phpauction.org/  
phpFormGenerator
A form generator featuring up to 100 form fields, all kind of input fields incl. file upload, customizable fields attributes, send submitted data to an email address or store them in a database, admin panel.
Un generatore di form catatterizzato dalla possibilita' di poter avere fino a 100 campi nel form, tutti i tipi di campi per l'input, invio dei dati del form ad un indirizzo email oppure memorizzazione degli stessi in un database, pannello di amministrazione.
Homepage: http://phpformgen.sourceforge.net/ 

osTicket
osTicket è un sistema per i ticket di supporto open source. È progettato per aiutare nelle richieste di supporto a flusso continuo e migliorare l’efficienza del servizio clienti offrendo allo staff gli strumenti necessari per offrire un supporto rapido ed efficiente. Può integrare in modo semplice le richieste create tramite moduli basati su e-mail, telefono e web con una interfaccia web multi-utente facile da usare.
http://osticket.com

Magento
Le piattaforme di eCommerce Magento offrono piattaforme ricche di funzioni per garantire ai commercianti una completa flessibilità e il controllo di presentazioni, contenuti e funzionalità dei propri canali online. Magento Community Edition è disponibile gratuitamente con licenza OSL 3.0 open source ed è consigliato a sviluppatori esperti e appassionati di tecnologia ad alto livello.
http://www.magentocommerce.com/it/

SugarCRM
Sugar è una piattaforma di gestione delle relazioni (CRM) facile da usare progettata per aiutare l’azienda a condividere le informazioni sulle vendite, chiudere accordi e soddisfare i clienti. Piccole, medie e grandi imprese possono utilizzare Sugar per gestire le vendite, marketing e supporto per migliorare la produttività delle vendite.
http://www.sugarcrm.com/

osCommerce
osCommerce Online Merchant è una soluzione e-commerce open source online gratuita dotata di molte funzioni per lo shopping online che consente ai proprietari di negozi di configurare, eseguire e gestire negozi online con il minimo sforzo e senza costi, tasse o altre limitazioni.
http://www.oscommerce.com

Zarafa
Zarafa - Zarafa provides open and compatible E-mail and groupware platform that can be used as a drop-in Microsoft Exchange replacement for email, calendaring, collaboration and tasks.
http://www.zarafa.com/

OpenERP
OpenERP è un pacchetto open source di applicazioni aziendali che include vendite, CRM, gestione progetto, gestione magazzino, produzione, contabilità e risorse umane.
http://www.openerp.com/

phpBB
phpBB® è un software bulletin board open source gratuito che può essere utilizzato per comunicare con le persone o per rendere più potente l’intero sito web. Grazie alle molte funzioni e al database di stili che contiene centinaia di stili e pacchetti di immagini per la personalizzazione della bacheca, è possibile creare un forum veramente unico in pochi minuti.
http://www.phpbb.com/

C-panel
http://www.cpanel.net/index.html
cPanel & WebHost Manager (WHM) is a next generation web hosting control panel system. Both cPanel & WHM are extremely feature rich as well as include an easy to use web based interface (GUI).
WHM allows you to but is not limited to administering individual accounts, reseller accounts & performing basic system and control panel maintenance via a secure interface.
For a complete list of features including screen shots of WHM, please click here.
cPanel is designed for the end users of your system and allows them to control everything from adding / removing email accounts to administering MySQL databases.
http://www.cpskins.com/
Vedi altro

Photo Gallery (by Yappa)
http://www.zirkon.at/zirkon/scripts/yappa-ng/yappa-ng_main_eng.html

Galleria Fotografica
http://www.photoonweb.com/it/

Slide-show di immagini
http://php.html.it/script/lista/56/slideshow-di-immagini/

Coppermine Photo Gallery
http://coppermine.sf.net/ 

CMS - Content Management System Vedi

Claroline
Claroline is an Open Source eLearning and eWorking platform allowing teachers to build effective online courses and to manage learning and collaborative activities on the web. Translated into 35 languages, Claroline has a large worldwide users’ and developers’ community.

Requirements
To install Claroline on a server, whether locally or remotely, you need the following devices on the computer:

Before proceeding to the Claroline installation, please ensure you read thoroughly the file called INSTALL.txt provided in the archive file.
http://www.claroline.net/

OSCommerce - Creazione di siti e-commerce
osCommerce Project Developers

http://www.oscommerce.com/
http://www.oscommerce.org/ 

What Is osCommerce?
osCommerce is an online shop e-commerce solution under on going development by the open source community. Its feature packed out-of-the-box installation allows store owners to setup, run, and maintain their online stores with minimum effort and with absolutely no costs or license fees involved. osCommerce combines open source solutions to provide a free and open e-commerce platform, which includes the powerful PHP web scripting language, the stable Apache web server, and the fast MySQL database server. With no restrictions or special requirements, osCommerce is able to run on any PHP enabled web server, on any environment that PHP and MySQL supports, which includes Linux, Solaris, BSD, Mac OS X, and Microsoft Windows environments.

Open Commercio
Software per e-commerce
http://www.opencommercio.com

MD-Pro (Max-Dev)
MaxDev è un completo, flessibile e affidabile CMS.
Compatibile con PHPNuke
Questi sono solo alcuni dei moduli al momento disponibili:
• e-Commerce
o PNCommerce (sistema di negozio elettronico)
o pnSubscriptions (sottoscrizioni al sito, donazioni, pagamenti PayPal, etc.)
o Stock_Quotes (per borse valori)
• Collaborazione e produttività
o Gestione progetti
o Organizzazione obiettivi
o Calendari
• Comunità virtuali e multimedia
o Gallerie di immagini
o Forum di discussione
o Chat
• Strumenti per Webmaster
o Un sistema avanzato di menu
o Statistiche di livello avanzato
o Strumenti per gestione lato server
• Altro
o Sondaggi
o Gestione form
o Newsletter
o Insegnamenti a distanza
http://www.maxdev.com/ - http://www.maxdevitalia.com/ - http://www.mdaddons.com/

Gestione faq in php
http://www.phpmyfaq.de   (**********)
http://www.boesch-it.de/sw/php-scripts/faqengine/english/
http://aphpkb.sourceforge.net/
FAQ Generator 2.5: http://www.expinion.net/software/app_faqgenerator.asp (ASP)
ITFA747: http://www.it747.com/
FAQ Master - free software - ( http://www.technetguru.net/design/faqmasterflex.php )
Purpose:
This is a database-driven application for creating and maintaining Frequently Asked Questions (FAQs).

Features

Unlimited Categories
Unlimited Questions/Answers
Web-based Category and FAQ Administration with Add, Edit, Delete Capability
http://www.technetguru.net/
http://www.technetguru.net/design/scripts.php

PHP Eclipse (editor multi-linguaggio) http://www.phpeclipse.de/

Webalbum generator http://www.ornj.net/

http://wbloggar.com/
Bloggar è un programma gratuito con il quale si possono gestire i post sui propri blog.
Permette di impaginare il post con tutti gli strumenti di un vero e proprio editor html, contiene un correttore ortografico che finora però contempla solo il dizionario inglese.
Anche l’interfaccia parla straniero si può scegliere tra portoghese, inglese o tedesco, ma è veramente intuitiva e non richiede grandi sforzi di comprensione.
La possibilità di gestire la storia, l’impaginazione, la creazione dei modelli per i post, rende Bloggar un programma veramente prezioso sia per un blogger navigato sia per chi si avvicina a questo mondo per la prima volta.
Infatti, all’avvio, Bloggar presenta all’utente una serie di siti che permettono di registrarsi ed aprire il proprio blog.
Per chi non è sempre connesso è ideale per aggiornare i post in un’unica soluzione alla connessione, un po’ come si fa con i client di posta elettronica.
Che siate blogger accaniti oppure curiosi di questo affascinante spicchio della rete, vale la pena fare un giro e provare questo programmino.

SQLite
SQLite
 (http://www.sqlite.org), a differenza di MySQL, PostgreSQL, Firebird e similari, e' una libreria C che implementa un motore Sql «embeddable», e supporta la maggior parte delle funzioni SQL92 (dettagli (http://www.sqlite.org/omitted.html)). Le versioni 5.x del PHP supportano SQLite nativamente, mentre per le versioni 4.x e' disponibile un package PECL (http://pecl.php.net/package/SQLite). E' inoltre possibile accedere a database SQLite tramite ADOdb (http://adodb.sourceforge.net/), il famoso database abstraction layer per PHP.

Caratteristiche

Sistema di licenza
I sorgenti di SQLite (http://www.sqlite.org) sono di pubblico dominio (dettagli (http://www.sqlite.org/copyright.html)).

http://devphp.sourceforge.net/
Dev-PHP is a full-featured integrated development environment (IDE), which is able to create scripts and applications using the PHP scripting language and the PHP-GTK library (both included in the "PHP Package").
Dev-PHP is free software under the GNU General Public License, which means you can freely modify or use the source code under the terms of the license.
Dev-PHP is a full-featured IDE for PHP. It is fast, it is powerful, it is easy to use and it has a lot of cool features like a class browser, an internal browser to preview scripts and full integration with the PHP parser and the PHP-GTK library.

Scripts are sorted alphabetically (Scarica qui)

PhpSiteStats (http://phpsitestats.sourceforge.net/ oppure scarica qui) è uno strumento per le statistiche sulle visite nei siti web. È una applicazione web-based, il che significa che gira su qualunque piattaforma e su qualunque server web purchè abbia un motore PHP.
PhpSiteStats è particolarmente indicato per tutti coloro che non avendo accesso ai files log del server vogliono comunque monitorare lo stato e la storia degli accessi al proprio sito.
Le opzioni di configurazione sono molto semplici e chiare. Si può scegliere se lavorare solo con file di log o se impostare una connessione a DB MySQL. Non è indispensabile l’accesso a un DBMS in quanto il programma processa i file di log che crea su ogni evento.
Una delle cose che colpisce e che non è da sottovalutare è la cura dell’aspetto del tool. Un layout funzionale e molto gradevole rende l’interfaccia ancora più immediata.
Una volta installato sul nostro sito il programma raccoglie le informazioni sulle visite e permette di estrarle attraverso grafici e tabelle riepilogative di facile interpretazione.
Le statistiche sono riportate per browser, per IP, per referrer, per sistema operativo. Mostra inoltre le attività degli spiders e le query che vengono rivolti al server web.
Ovviamente permette anche la visualizzazione del contatore di visite sul sito e le operazioni di monitoraggio sono possibili solo a chi possiede un account da amministratore.
Il programma è rilasciato sotto licenza GPL, quindi è del tutto gratuito. Vale la pena di essere provato.

Interchange
http://www.icdevgroup.org 
Interchange is an open source alternative to commercial commerce servers and application server/component applications. Interchange is one of the most powerful tools available to automate and database-enable your web site or build online applications.
Interchange is well suited for a variety of purposes, including: sales, order processing, content management, customer service, reporting and analysis, and personalization. Interchange has been implemented for traditional retail sales, digital goods delivery, B2B parts re-ordering, non-commerce content management, auctions, order status checking, supply chain management, project management, online collaboration, and even an MP3 Jukebox. Interchange can be used as a completely self-contained standalone product or as part of a larger system. It can be integrated with payment processing services, ERP systems, point-of-sale systems, accounting systems, external content management systems, Java-based application servers, sales force automation systems, customer relationship management systems, email campaign management systems, and remote databases on virtually any platform.
NOTE: This site runs on Interchange, typically the latest development release. Current running version (from [version] tag): 5.0.0
At its core, Interchange is a flexible, high performance application server that handles state management, authentication, session maintenance, click trails, filtering, URL encodings, security policy. It's made up of the following components:
* database abstraction layer
* generic templating system
* transaction routing rules
* customer information object
* universal localization scheme
* security blackout definition
* profiles
* filters
* search language
* session management 
Some of Interchange's many modules are transaction management, pricing, personalization, payment processing, reporting, customer service, and search.
Interchange templates are simply HTML pages with specialized Interchange-specific markup tags called ITL (Interchange Tag Language). ITL allows for a highly customizable combination of components to be displayed on the page, both static and dynamic. There are several classes of ITL tags, including:
# built-in tags - A library of pre-built tags that enable Interchange functionality
# user tags - custom designed tags that can be created for any purpose
# localization - tags that allow multi-language or multi-locale implementation
# "Perl" and "ASP" tags - allow the insertion of Perl or ASP code into templates
If you need functionality that Interchange doesn't yet provide, it is easy to incorporate it yourself in an extensible way that survives upgrades. If you don't have the time or expertise to do so, there is a strong group of consultants who inhabit the the user mail list who can help you produce it.
Caveat: Interchange is not presented as being easy to use, easy to install, or bug-free.
Thousands of people use Interchange, and it has taken hundreds of millions of dollars worth of orders in its time. But there is a definite learning curve required to use Interchange. If you are looking to Interchange for e-commerce, and all you have to sell is a few items, it may well be overkill for your needs. But if you need a sophisticated ordering or content-management system with unlimited room to grow, Interchange may be right for you.

Foruminsider è una vetrina dedicata ai forum di discussione. Contiene un lunghissimo elenco comprensivo della maggior dei prodotti di questo tipo presenti in rete.
http://www.foruminsider.com/

WapReader is WAP-based PHP email client. It use IMAP/POP3 protocols to connect to mail server.
* Development Status: 5 - Production/Stable
* Intended Audience: Customer Service
* License: GNU General Public License (GPL)
* Operating System: All BSD Platforms (FreeBSD/NetBSD/OpenBSD/Apple Mac OS
X), All POSIX (Linux/BSD/UNIX-like OSes), OS Independent (Written in an
interpreted language), FreeBSD, Linux
* Programming Language: PHP
* Topic: Email Clients (MUA)
* Translations: English
* User Interface: Web-based
http://sourceforge.net/projects/wapreader
http://wapreader.dp.ua/en/screenshots

Opensourcecms.com
Tutti i CMS disponibili in rete, e non solo....
Troviamo , blog, gallerie di foto, negozi internet, forum di discussione, pacchetti di e-learning e soluzioni tipo groupware e wiki.
http://www.opensourcecms.com/

CMS Matrix
Altra raccolta di CMS
http://www.cmsmatrix.org

PHP Forms (a pagamento)
PHP Forms is the advanced web form builder that allows you to create web forms fast and with minimum of effort. Web forms are easily integrated into your website: just insert the php form code or html form code into your page.
Now you can add more interactivity and attractiveness to your website, draw visitors' attention to professionally designed web forms and gather user information for further processing and analysis. PHP Forms does all that… and even more.
http://phpforms.net/

phpXplorer
phpXplorer is an open source file management system written in PHP. It enables you to work on a remote file system through a web browser. By default it has got dialogs for editing HTML, PHP, image, Apache, compressed and email files.
Its modular design makes it easy to build your own filetypes, property sheets, views and themes. phpXplorers permission manager enables you to restrict the access to the shared file system for multiple users in a detailed way.
http://www.phpxplorer.org/phpXplorer/webIndex.php

phpPgAdmin
phpPgAdmin is a web-based administration tool for PostgreSQL. It is perfect for PostgreSQL DBAs, newbies and hosting services.
http://phppgadmin.sourceforge.net/

phpMyBackupPro (simile a phpmyadmin)
phpMyBackupPro is a Web-based MySQL backup program. You can schedule backups (without cron jobs), and download, email, or upload backups with FTP. File directories can also be backed up. No compression, zip compression, or gzip compression of the backups is possible. HTTP or HTML authentication is possible. It has an easy user interface and is easy to install. Many languages and online help are available.
http://freshmeat.net/projects/phpmybackup
 
MercuryBoard
MercuryBoard is a powerful message board system dedicated to raw speed with a mixture of features, ease of use, and ease of customization coupled with expandability, and diverse language services. Now just over two years in the making, version 1.0.0 is an immensely stable, thoroughly tested, and well-written piece of internet software ready for any webserver, running on PHP versions as low as 4.0.0 and MySQL versions as low as 3.22.
http://mercuryboard.com/

ShoutChat
ShoutChat is a PHP script, released under the LGPL license, which gives developers the capability to add an instant messaging module to their web sites. It uses an early version of AJAX (long before the hype), and will operate in most modern browsers. By using this tool, simultaneous web site visitors are able to chat with one another, in real time, without any prior arrangements. Example uses include web sites for weblogs, projects and discussion boards.
The ShoutChat module is implemented as an IFRAME element (primary to have more control over scrolling). The client part communicates with the server part through the use of client-side Javascript (XMLHttpRequest). The messages are
then stored in a MySQL database, which is then queried for updates. The look of the box can be customized primarily by using CSS.
ShoutChat handles some of the details that other chat scripts leave out. When a new message is posted, the message frame scrolls down so that any new messages come into view. ShoutChat also checks for new messages using a client-server model. The query for new messages is done using HTTP HEAD requests once every 10 seconds for the first 30 seconds and then exponetially by powers of 2 from there on out (an algorithm which can be configured). When the mouse is moved over the ShoutChat region of the web page, this cycle starts over. This allows for new messages to be displayed immediately to all active users, while tapering off the rate of checking for message by inactive clients to reduce server load. Without these very important features, a converstation on a website is much more cumbersome.
Now that AJAX has finally hit the mainstream, this program is no longer anything out of the ordinary. However, one could argue that it was certain ahead of its time. This chat application is described in a nutshell in the java.net article Developing AJAX Applications the Easy Way. As an exercise, ShoutChat will be reimplemented using DWR and a new version will finally be released.
http://mojavelinux.com/projects/shoutchat/

PHP2Go
PHP2Go is a development framework designed to help experienced developers and beginner programmers to create Web-based Systems. It's and object-oriented, structured and hierarchical set of classes and libraries developed using PHP, XML and JavaScript. The main goal of PHP2Go is to be a complete code repository to build systems with code reuse, object orientation, separation between logic and presentation code and database transparency. All the components of the API have the same purpose: to create an object oriented abstraction layer that runs over the powerful PHP API, providing an organized, structured and easier way to create HTML documents, HTML forms, database or file data sets, reports, HTML templates and much more.
Some of the features and components that you'll find inside PHP2Go:
* complete database integration
* HTML documents and HTML templates construction
* form construction through a powerful API, using XML descriptors
* I/O components (file, directory)
* data compression (tar, zip, gzip)
* data encryption and decryption
* cross-browser javascript library
* network connectivity through client components (FTP, HTTP, Socket, cURL,
POP3, SMTP)
* mail MIME messages construction
* XML parsing and rendering
* authentication handling
* cache manager
* session handling, allowing persistence of custom objects
* data sets construction using database, CSV, XML or arrays
* paged data sets
* HTML reports using XML descriptors
* data validators
* string and date manipulation
It's strongly recommended to read the examples included in the project and browse all the classes documentation, to know all the features provided by the components. Some of the most common needs of a PHP developer were included in this framework, planned and implemented in a way that the task of building the layers of a system can be easy, fast and agile.
Soon you'll see that, inside the framework, there's an easier way to do some common tasks you're used to do in your work with PHP. Get to know the framework, class by class, reading the examples and the API documentation.
The PHP2Go Web Development Framework is fully compatible with PHP 5. However, none of the new features (iterators, exceptions, destructors, method modifiers) are been used, to maintain compatibility with PHP 4 (the requirement to run PHP2Go is PHP 4.1.0).
http://php2go.sourceforge.net/

Vice Stats
E' un programma per le statistiche delle visite al nostro sito. Raccoglie gli indirizzi, dai quali è stata richiamata la nostra pagina, il nome del motore di ricerca, grazie al quale i visitatori arrivano a noi, il numero odierno di visitatori in ingresso, quello del giorno precedente (divisi per ora) e anche quello della settimana, mostra inoltre il richiamo di risorse specifiche (file).
http://www.arantius.com/topic/arantius/vice+stats

"LMS" (LAN Management System)
"LMS" (LAN Management System) is the integrated system of networks management designed for various size internet providers (ISP).
That software writed in PHP, Perl and C, works with variuos database systems. It consists a friendly web user interface (frontend) and programs installed on servers (backend). The main features of LMS are:
- internet access administration (e.g. traffic control and stats),
- finances with invoicing (automatic billing),
- database of customers and network devices (network map),
- serial mailing and administration messages to customers,
- hosting and accounts management,
- bug tracking system (helpdesk),
- any services management,
- time organizer (timetable),
- customer web panel.
LMS is opensource application (licensed on GNU/GPL), so you are free to use it without any charges!
http://lms.rulez.pl

phpMyBackup is an mySQL backup tool, with features like copying backups to a different server using FTP
http://sourceforge.net/projects/pmbackup/

PhpWebGallery is a web application that enables you to create images gallery online easily
http://www.phpwebgallery.net/eng/index.html

Assistenza online
Creare una Chat Live per assistenza online sul proprio sito web
Quante volte ci è capitato di vedere una immagine su un sito, molto spesso con una bella ragazza, che ci invita a cliccarci sopra per chiedere ulteriori informazioni o per darci assistenza durante la visita di un sito web.
Si tratta di chat di assistenza online, attraverso le quali, molti siti, ad esempio di e-commerce, danno una assistenza diretta via chat in tempo reale rispondendo alle domande dei possibili acquirenti senza che questi ultimi siano costretti a scrivere e-mail o telefonare.
Attraverso queste chat live è possibile non solo dialogare con gli utenti che lo desiderino, ma anche verificare ogni accesso al sito e in quelle più complete sapere quali pagine sta visitando l'utente appena entrato sul proprio sito web.
Installare CS Live Help
Requisiti:
- un webserver (preferibilmente Apache)
- php
- database mySQL
Questo e' uno script in Php open source che consente di monitorare i visitatori del proprio sito. Se sia i visitatori che l'amministratore sono on-line e' possibile chattare. Altrimenti viene offerta la possibilità di lasciare un messaggio.
Cominciamo recandoci all'homepage dell'autore dello script e scarichiamo lo script zippato.
Il file zippato andra' decompresso in locale (rispettando la struttura delle directory), creando una cartella livehelp_1_0 che possiamo rinominare live o in qualsiasi modo vogliamo.
Lanciamo il programma ftp e trasferiamo la cartella sul server, avendo cura che venga rispettata la struttura (directory e sottodirectory) e che i file d'immagine vengano trasferiti in modalita' binaria.
Finito l'upload, e' necessario cambiare i permessi dei file config.php e livehelp.js, portandoli a 777
Fatto questo, bisogna aprire tramite browser la pagina corrispondente al file setup.php. Se tutto e' andato bene, vi verranno chiesti alcune informazioni come lo username, password, e-mail, URL e percorso assoluto (fate attenzione che ci siano tutti gli slash; nel mio caso se ne mangiava uno e lo script non funzionava), e i dati di accesso al database mySQL (in alternativa potete usare file di solo testo per conservare le informazioni, specificando il percorso della directory).
Terminata l'installazione, provando ad accedere alla directory principale vi verranno chiesti username e password. Una volta autenticati, potrete scegliere se entrare nel pannello di controllo, o visualizzare il codice html da inserire nelle vostre pagine. Senza quest'ultimo passo, sara' ovviamente impossibile interagire con i visitatori.
Il pannello di controllo e' spartano ma sufficientemente valido. Ho provato a chattare con me stesso (lo so, ho bisogno di vacanze!!!) e, sia per il visitatore che per l'operatore l'operazione e' semplice e rapidissima. Ovviamente e' possibile aggiungere altri operatori.
Se non siete collegati al pannello di controllo o se scegliete lo status "offline", il visitatore potra' lasciarvi un messaggio.
Tutto sommato, considerando che script simili sono a pagamento, questa e' un'ottima soluzione per tenere sotto controllo ed interagire con i vostri visitatori.

Tutorial su Joomla vedi

Statistiche del proprio sito
http://www.phpmyvisites.net/

PHPGroupWare
Una suite web di strumenti di condivisione del lavoro. Anche in lingua italiana.
Tra i 47 moduli: addressbook, admin module, bookmarks, calendar, chat, filemanager, forum, infoblog, hr (lista utenti), note, manual, preferences, projects, todo, tts (ticket per richieste), wiki.
http://www.phpgroupware.org
Una suite Web di strumenti di condivisione del lavoro
Condividere le informazioni in modo efficiente ed efficace sia in ufficio che in aziende di grandi dimensioni è basilare. PhpGroupWare è un software ricco di tool adatti allo scopo.
Nell'era digitale in cui ci troviamo ci stiamo sempre più accorgendo che la ricchezza è data dall'informazione e in particolare modo dalla condivisione dell'informazione. Il progresso tecnologico ci ha messo a disposizione strumenti avanzatissimi grazie ai quali possiamo virtualmente condividere qualsiasi cosa con chiunque in qualunque luogo. Questo avviene, ad esempio, con le pagine web di un sito internet, e a maggior ragione con strumenti più snelli e agili come le mailing list, le newsletter e i gruppi di discussione e i più recenti wiki e blog.
Se la condivisione delle informazioni è importante per la vita di tutti i giorni, diventa assolutamente basilare in ambito lavorativo.
In un'azienda di qualunque dimensione, ma anche in un piccolo ufficio, vi sono moltissime informazioni che devono essere condivise tra più persone in modo da rendere il lavoro di tutti più efficiente ed efficace.
Pensiamo, ad esempio, ai nominativi e ai riferimenti di contatto dei clienti: queste informazioni sono basilari per un'azienda, ma spesso sono conservate da una sola persona che, in ogni momento, potrebbe lasciare l'azienda! Il caso contrario, ugualmente negativo per il lavoro, si manifesta quando le info su un cliente sono magari diffuse all'interno dell'azienda ma non sono sincronizzate, quindi non si sa dove siano quelle più aggiornate.
Un altro esempio si ha con la gestione dei progetti: se un progetto, come spesso accade, coinvolge più persone si dovrebbe avere una piattaforma condivisa per la gestione delle attività in modo che tutte le persone coinvolte possano vedere l'avanzamento dei lavori.
Questi sono solo due semplici esempi, ma ne potremmo citare molti altri: un'agenda condivisa permette di sapere quali sono gli impegni dei colleghi e dei capi, uno spazio condiviso per i file consente agli interessati di avere un unico punto di raccolta per i file, un sistema di gestione delle segnalazioni dei clienti permette di non dimenticarle e di vedere a chi sono state assegnate e cosa sia stato fatto per risolverle. Condividendo le informazioni sicuramente l'azienda/ufficio non solo migliora le proprie performance interne, ma al contempo migliora anche le proprie prestazioni verso l'esterno (ossia verso i clienti).
Per attuare, quindi, la gestione condivisa delle informazioni possiamo avvalerci dei nuovi strumenti informatici: ci sono molti software che mettono a disposizione molteplici strumenti per gestire le varie attività che si ritiene opportuno condividere (ovviamente ogni azienda valuterà cosa sia bene condividere tra le persone e cosa non lo sia).
Tra questi abbiamo scelto di trattare phpGroupWare, una suite di moduli che consentono di attuare la condivisione delle informazioni sopra descritta. phpGroupWare gira su un server e vi si accede usando un browser qualsiasi (Explorer, Firefox, Opera, ...).
Il programma può essere installato solo per uso interno, oppure si può scegliere di dare accesso al software (previa autenticazione) da qualunque luogo, usando una connessione internet o tramite VPN. La seconda soluzione ha l'indubbio vantaggio che rende possibile il recupero delle informazioni da ogni luogo (pensiamo a chi viaggia per lavoro) e non solo dall'ufficio.
Cos'è phpGroupWare
phpGroupWare è una suite di strumenti che, in ultima analisi, consentono di condividere informazioni di vario genere.
È uno strumento moderno, flessibile, ricco di funzioni e strumenti. Lo stesso sito web ufficiale lo definisce così: “phpGroupWare (phpgw) is many things” (PHPGroupWare è molte cose!.
Ed è effettivamente così: troviamo moduli (teniamo sempre presente che la parola condivisione è in primo piano) come l'agenda (consente anche di convocare riunioni), la rubrica, il forum, il file manager, la gestione dei reclami (un piccolo CRM), la gestione dei progetti, la to-do list, la chat, la gestione delle news e degli account e via dicendo.
Il software è scritto in linguaggio PHP ed è liberamente utilizzabile per qualsiasi scopo in quanto rilasciato sotto la famosa licenza libera GPL. È possibile modificare il codice sorgente se desideriamo aggiungere nuove funzioni e creare nuovi moduli se non siamo soddisfatti di quello che abbiamo a disposizione.
Per installare il programma basta avere a disposizione un server (interno o esterno all'azienda) che supporti il linguaggio PHP (versione superiore alla 4.1) e un database (MySQL, PostgreSql, Oracle-DB e molti altri). L'accesso al software avverrà poi tramite la rete intranet o internet utilizzando un normale browser web, previa autenticazione con login e password.
È anche possibile installare phpGroupWare sul proprio PC, sia per fare una prova offline sia per usarlo (come unico utente) per il proprio lavoro, avendo cura di rispettare i requisiti richiesti. L'amministratore del programma può settare ogni tool e creare infiniti utenti e gruppi cui attribuire i diversi diritti di accesso, modifica, scrittura e cancellazione delle informazioni. Ogni utente, in aggiunta, potrà a sua volta stabilire alcuni diritti di accesso alle info da esso inserite, curando che questi non vadano in contrasto con quelli dei gruppi (questi ultimi hanno la precedenza).La struttura modulare del programma lascia molta libertà in quanto consente di installare solo i moduli che effettivamente useremo rimuovendo quelli che non consideriamo utili (ma sarà sempre possibile installarli in un secondo momento).
Molto interessante è la possibilità di interfacciare phpGroupWare con il server di posta elettronica (POP3 o IMAP che sia): in questo modo si possono attivare allarmi e comunicazioni automatiche che verranno inviate dal sistema alle persone interessate quando si verificano certe azioni o sono fatte modifiche di cui si deve essere a conoscenza.
Tutti i moduli condividono lo stesso “spazio” (inteso come spazio fisico e come database) con un flessibile sistema di controllo degli accessi (ACL, Access Control List) che, come detto, gestisce tutte le possibili interazioni con grande attenzione anche al lato sicurezza.
Tra le altre cose, phpGroupWare è multilingua e ci lascia scegliere tra diversi temi di visualizzazione secondo i nostri gusti. Riassumendo i punti di forza di phpGroupWare si possono individuare in:
* architettura modulare
* moduli pensati per la gestione condivisa delle informazioni
* accesso e inserimento delle info tramite interfaccia web (quindi vi si può accedere usando qualsiasi sistema operativo su cui sia installato un browser)
* possibilità di accesso alle informazioni da ogni luogo (basta avere un collegamento a internet)
* procedure di sicurezza avanzate per prevenire illeciti accessi
* precisa gestione dei diritti degli utenti e dei gruppi
* licenza GPL
* utilizzo di un'architettura server molto diffusa (ogni server gestisce PHP e un database)
* scelta tra molti database di supporto (MySQL, PostgreSQL, Microsoft SQL Server, Oracle-DB, SAPDB)
* installazione guidata intuitiva
* supporto multilingua (italiano compreso).
Installazione
Per installare phpGroupWare bisogna innanzitutto fare il download dell'archivio zippato che contiene il codice del programma.
L'azione successiva consiste nello scompattare l'archivio nel server nella posizione voluta: il consiglio è di mantenere il software all'interno della cartella denominata “phpgroupware”.
Ora apriamo il nostro browser preferito e scriviamo l'url per accedere alla prima configurazione del programma: l'indirizzo sarà qualcosa del tipo: http:///phpgroupware
Saremo automaticamente indirizzati alla pagina di configurazione del file header.inc.php nella quale dovremo inserire le informazioni di collegamento al database. Una veloce analisi automatica da parte del programma individuerà i tipi di database gestiti dal nostro server, quindi passeremo all'inserimento delle informazioni.
Le caselle server root e include root dovrebbero essere già precompilate, mentre dovremo inserire la password che in futuro useremo per accedere alla pagina dove ci troviamo ora.
Nella parte bassa della finestra bisogna fare attenzione a inserire i dati corretti di collegamento al database, quindi va scritta la password che useremo per l'accesso alla pagina generale di configurazione. Clicchiamo poi su write config e quindi su continue.
Verremo ora reindirizzati sulla vera pagina di accesso alle configurazioni: la parte alta (setup/config admin login) serve per accedere alla configurazione generale (inseriamo la seconda password scritta in precedenza), mentre agendo sulla parte bassa della finestra (header admin login) rientreremo (usando la prima password inserita) nella pagina header.inc.php già configurata.
Notate che per accedere a questa pagina di login bisognerà in futuro scrivere come indirizzo: http:///phpgroupware/setup
Inseriamo la password nella parte alta della pagina per entrare nella configurazione setup/config. La pagina che si apre è divisa in 4 “passaggi”. Il primo ci informa sulla situazione del database: nel caso non sia ancora andata a buon fine la creazione delle tabelle di gestione, si può seguire il consiglio riportato o tentare di fare creare il database dal programma immettendo i dati di collegamento.Clicchiamo poi su recheck per verificare se tutto è andato a posto. Senza database, ovviamente, non può funzionare nulla.
Il secondo passaggio permette di impostare alcune variabili generiche, il terzo ci lascia impostare la lingua (c'è l'italiano), mentre il quarto consente di installare e/o rimuovere i vari moduli del programma.
Ora dovrebbe essere tutto “verde”, ma prima di uscire dalla pagina resta una cosa fondamentale da fare: settare i dati per l'amministratore.
Clicchiamo allora sul link che è comparso all'interno del “passaggio 2” e inseriamo i dati. Fatto questo usciamo dalla configurazione e poi scriviamo: http:///phpgroupware
Adesso ci troviamo di fronte alla pagina di autenticazione utenti: inseriamo i dati dell'amministratore appena creato così da entrare, finalmente, in phpGroupWare.
La prima azione da fare per motivi di sicurezza, come consigliato, è modificare la password. Ora siamo pronti a navigare tra i moduli e ad impostare il programma secondo le nostre esigenze.
Utenti, moduli e opzioni di configurazione
La scoperta di tutte le funzioni e le opzioni del programma va al di là dei propositi di questo articolo di presentazione, ma sicuramente è utile dare alcune informazioni che rendono più facile l'impatto con il software.
La finestra che si apre dopo il login ha un aspetto diverso a seconda del “tema” grafico che l'utente ha scelto. Ogni persona, infatti, sia essa amministratore o utente, può cliccare sul link preferenze e quindi su preferenze -> cambia le tue impostazioni per modificare l'aspetto generale delle pagine (tema grafico, lingua, ora, aspetti di visualizzazione, pagina predefinita di apertura...).
Cliccando poi sulle icone si accede ai vari moduli del programma, o meglio si accede solo a quei moduli per i quali il gruppo cui apparteniamo ha i corretti diritti di lettura e/o scrittura e/o modifica.
L'amministratore vede anche un'altra icona (amministrazione) grazie alla quale può accedere a tutta una serie di configurazioni che coinvolgono il programma, i moduli e gli utenti. In particolare, l'amministratore dovrà settare con attenzione i gruppi (è fondamentale la decisione sull'accesso ai vari moduli presenti) e gli account degli utenti (login, password, scadenza password, gruppi di appartenenza, diritti, ...). L'amministratore, cliccando su applicazioni, potrà anche decidere quali moduli installare o disinstallare, scegliendo anche ordine di visualizzazione sulla barra delle icone.
L'utilizzo dei moduli del programma è piuttosto semplice. Ogni modulo, e come esempio prendiamo l'agenda, si avvia cliccando sulla corrispondente icona: si accederà ad una generica pagina riassuntiva nella quale vedremo le informazioni cui abbiamo accesso (o perché le abbiamo create noi o perché siamo abilitati a visualizzarle).
Sulla sinistra della finestra appariranno i link che consentiranno di eseguire alcune azioni, come l'inserimento di un nuovo evento, ed anche quelli (fondamentali) che permettono di settare le mie “preferenze” e i diritti di accesso riferiti a quel modulo.
Tra le preferenze, nel caso specifico, troviamo le opzioni che consentono la spedizione automatica delle e-mail per invitare le persone alle riunioni o per far conoscere loro le variazioni nella mia agenda, mentre con gli accessi stabilisco cosa possano vedere e fare gli altri utenti rispetto alle informazioni da me inserite.
Tutti i moduli ricalcano più o meno questo schema, ossia propongono un quadro riassuntivo (che si può poi dettagliare) dipendente dai nostri diritti, con gli eventuali link cliccabili (sulla sinistra della pagine o nelle info stesse) che consentono di operare sul modulo.

PHP Manual Creator ***** OTTIMO *****
Create and manage manuals for any product
http://www.kubelabs.com/phpmanualcreator/