Logistoris

KPI - INDICATORI CHIAVE DI PERFORMANCE

2012-09-17T00:54:00.001-07:00

KPI - INDICATORI CHIAVE DI PERFORMANCE

I kpi consentono un controllo ed una misura dei parametri caratteristici di sviluppo di una qualsiasi organizzazione.

Sono uno strumento indispensabile per valutare una qualsiasi impostazione ed iniziativa organizzativa. Consentono delle valutazioni confrontabili ed impegnative nei confronti di operatori direttivi.

KPI AZIENDE ITALIANE PRINCIPALI

KPI ONLINE

Trova online!

link a rss

2011-10-30T02:56:00.000-07:00

link a rss su argomento pelle e borse

xmplparser esempio php

2011-10-27T15:08:00.000-07:00

<?php

$data = "
  <overlays>
    <overlay>
      <name>Test</name>
      <type>template</type>
      <syntax>
&lt;div id=quote&gt;
&lt;b&gt;This should be bold&lt;/b&gt;
&lt;/div&gt;
      </syntax>
    </overlay>
  </overlays>";

class xml2Array {
  
   var $arrOutput = array();
   var $resParser;
   var $strXmlData;
  
   function parse($strInputXML) {
  
           $this->resParser = xml_parser_create ();
           xml_set_object($this->resParser,$this);
           xml_set_element_handler($this->resParser, "tagOpen", "tagClosed");
          
           xml_set_character_data_handler($this->resParser, "tagData");
      
           $this->strXmlData = xml_parse($this->resParser,$strInputXML );
           if(!$this->strXmlData) {
               die(sprintf("XML error: %s at line %d",
           xml_error_string(xml_get_error_code($this->resParser)),
           xml_get_current_line_number($this->resParser)));
           }
                          
           xml_parser_free($this->resParser);
          
           return $this->arrOutput;
   }
   function tagOpen($parser, $name, $attrs) {
       $tag=array("name"=>$name,"attrs"=>$attrs);
       array_push($this->arrOutput,$tag);
   }
  
   function tagData($parser, $tagData) {
       if(trim($tagData)) {
           if(isset($this->arrOutput[count($this->arrOutput)-1]['tagData'])) {
               $this->arrOutput[count($this->arrOutput)-1]['tagData'] .= $tagData;
           }
           else {
               $this->arrOutput[count($this->arrOutput)-1]['tagData'] = $tagData;
           }
       }
   }
  
   function tagClosed($parser, $name) {
       $this->arrOutput[count($this->arrOutput)-2]['children'][] = $this->arrOutput[count($this->arrOutput)-1];
       array_pop($this->arrOutput);
   }
}

$x = new xml2Array( );

$x->parse( $data );

print_r( $x->arrOutput );
?>

trucchi ed esempi php

2011-10-27T14:39:00.000-07:00

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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


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

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

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

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

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

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

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

require("./html_graphs.php3");

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

require("./HTML_Graphs.php3");

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

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

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

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

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

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

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

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

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

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

<?

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

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

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

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

?>

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

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

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

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

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

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

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

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

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

flock($fp, 2);

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

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

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

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

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

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

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

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

require('HTML_Graphs.php3');

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

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

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

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

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

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

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

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

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

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

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

<?

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

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

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

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

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

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

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

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

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

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

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

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

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

<?
}
?>

</body>
</html>

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

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

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

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

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

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

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

'type' => 1

Come fare un sondaggio



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

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

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

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

Questa applicazione e ha i seguenti file.... 

1)db_connect.php 

2)install.php 

3)scegli.htm 

4)vai.php 

5)guarda.php 

6)vota.gif 

Guardiamoli uno per uno le loro funzionalità 

1)db_connect.php 

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

PHP:


  <?php 

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

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

  ?>

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

2)install.php 

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

PHP:


  <?php 

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

  if ($connessione) {
  

  echo "Connessione a mysql riuscita<br>";
  

  }else{ 

  echo" Connessione fallita<br>";
  

  } 

  

  $database=  mysql_create_db(sondaggio,$connessione);

  

  if ($database) { 

  echo "Creazione  database riuscita<br>";
  

  }else{ 

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

  } 

  

  $db_name="sondaggio";
  

  $selezione= mysql_select_db($db_name);
  

  if ($selezione) {
  

  echo "Selezione  database riuscita<br>";
  

  }else{ 

  echo" Selezione fallita<br>";
  

  } 

  

  $creatabella= "CREATE 
  TABLE nomi ( 

  id INT (5) UNSIGNED not null AUTO_INCREMENT, 

  italia  DECIMAL, 

  portogallo  DECIMAL, 

  spagna  DECIMAL, 

  francia  DECIMAL, 

  inghilterra  DECIMAL, 

  PRIMARY KEY (id))"; 

  

   $crea=mysql_query($creatabella,$connessi

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

  

  

  if ($crea) { 

  echo "Creazione Tabella riuscita<br>";
  

  }else{ 

  echo" Creazione  Tabella fallita<br>";
  

  

  

  } 

  

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

  VALUES( 

  '0', 

  '0', 

  '0', 

  '0', 

  '0' 

  ) 

  

  "; 

  

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

  

  if ($crea) { 

  echo "Inserimento riuscito<br>";
  

  }else{ 

  echo"Inserimento Fallito<br>";
  

  } 

  

  mysql_close(); 

  ?>

leggere feed

2011-10-24T14:48:00.001-07:00

<?php

  $doc = new DOMDocument();
  $doc->load('http://www.softarea51.com/rss/windows/Web_Development/XML_CSS_Utilities.xml');
  $arrFeeds = array();
  foreach ($doc->getElementsByTagName('item') as $node) {
    $itemRSS = array ( 
      'title' => $node->getElementsByTagName('title')->item(0)->nodeValue,
      'desc' => $node->getElementsByTagName('description')->item(0)->nodeValue,
      'link' => $node->getElementsByTagName('link')->item(0)->nodeValue,
      'date' => $node->getElementsByTagName('pubDate')->item(0)->nodeValue
      );
    array_push($arrFeeds, $itemRSS);
  }

?>

Fedd rss

2011-10-24T13:59:00.001-07:00

Specifiche RSS 2.0

Traduzione italiana delle specifiche inglesi del formato RSS 2.0.

Note di traduzione
La presente documentazione è una traduzione italiana delle specifiche RSS 2.0, pubblicate da RSS Advisory Board il 12 Agosto 2006.

L'URI di questo documento è http://www.specifiche.it/rss/2.0/
L'URI della versione originale in lingua inglese è http://www.rssboard.org/rss-2-0-8
L'URI della versione più recente in lingua inglese è http://www.rssboard.org/rss-specification

Questo documento è da considerare come risorsa di supporto. L'unica versione normativa è rappresentata dalle specifiche ufficiali in lingua inglese.
La traduzione italiana è stata eseguita da Simone Carletti <weppos@weppos.net>. Traduzione completata il 2006-04-16.
Nonostante sia stata usata la massima cura possibile nella fase di traduzione, non si esclude la presenza di errori nel presente documento. Qualsiasi errore individuato e segnalato all'autore della traduzione verrà verificato e corretto nel più breve tempo possibile.

Che cos'è l'RSS?

L'RSS è un formato per la distribuzione di contenuti nel Web.
Il suo nome è acronimo di Really Simple Syndication.
L'RSS è un dialetto dell'XML. Ogni file RSS deve essere conforme alle specifiche XML 1.0, così come pubblicato sul sito del World Wide Web Consortium (W3C).
Cronologia delle versioni dell'RSS.
Al livello più alto, un documento RSS è costituito da un elemento <rss> con un attributo obbligatorio chiamato version, che specifica la versione RSS con la quale il file risulta conforme. Per essere conforme a queste specifiche l'attributo version deve avere come valore 2.0.
Subordinato all'elemento <rss> è l'elemento <channel>, che contiene informazioni relative al canale (metadati) e il suo contenuto.

File di esempio

Ecco alcuni file di esempio per: RSS 0.91, 0.92 e 2.0.
Da notare che i file di esempio potrebbero puntare a documenti o servizi non più esistenti. L'esempio 0.91 è stato creato nel momento in cui è stata scritta la documentazione per la versione corrispondente. Mantenere una traccia degli esempi è sembrata una buona idea.

Informazioni su questo documento

Questo documento rappresenta lo stato dell'RSS nell'autunno del 2002, versione 2.0.1.
Incorpora tutti i cambiamenti e le aggiunte, cominciando dalle specifiche di base per l'RSS 0.91 (Giugno 2000) ed include le nuove caratteristiche introdotte con l'RSS 0.92 (Dicembre 2000) e l'RSS 0.94 (Agosto 2002).
Le note relative alle modifiche sono riportate qui.
In primo luogo queste specifiche documentano i sottoelementi obbligatori ed opzionali per l'elemento <channel>; in seguito quelli per l'elemento <item>. La sezione finale contiene risposte alle domande più frequenti e fornisce una roadmap per evoluzioni future, oltre che linee guida estendere l'RSS.

Elementi obbligatori per channel

Questa è una lista degli elementi obbligatori per <channel>, ciascuno con una breve descrizione, un esempio e, dove disponibile, un collegamento ad una risorsa maggiormente descrittiva.

Elemento	Descrizione	Esempio
title	Il nome del canale. Per gli utenti rappresenta il riferimento a chi fornisce il servizio. Se è disponibile un sito che presenta le stesse informazioni del file RSS, il titolo del canale (channel) dovrebbe essere lo stesso titolo del sito web.	GoUpstate.com News Headlines
link	L'URL del sito web HTML che corrisponde al canale.	http://www.goupstate.com/
description	Una frase o un riassunto per descrivere il canale.	The latest news from GoUpstate.com, a Spartanburg Herald-Journal Web site.

Elemento

Descrizione

Esempio

title

Il nome del canale. Per gli utenti rappresenta il riferimento a chi fornisce il servizio. Se è disponibile un sito che presenta le stesse informazioni del file RSS, il titolo del canale (channel) dovrebbe essere lo stesso titolo del sito web.

GoUpstate.com News Headlines

link

L'URL del sito web HTML che corrisponde al canale.

http://www.goupstate.com/

description

Una frase o un riassunto per descrivere il canale.

The latest news from GoUpstate.com, a Spartanburg Herald-Journal Web site.

Elementi opzionali per channel

Questa è una lista degli elementi opzionali per <channel>.

Elemento Descrizione Esempio

language La lingua nella quale è scritto il canale. Questo tag consente agli aggregatori di raggruppare tutti i siti italiani, per esempio, in una singola pagina. Una lista di valori consentiti per questo elemento, così come fornita da Netscape, è disponibile qui. E' possibile usare i valori definiti dal W3C. en-us

managingEditor Indirizzo email della persona responsabile dei contenuti editoriali. geo@herald.com (George Matesky)

webMaster Indirizzo email della persona responsabile dei problemi tecnici relativi al canale. betty@herald.com (Betty Guernsey)

pubDate Sat, 07 Sep 2002 00:00:01 GMT

lastBuildDate La data dell'ultima modifica dei contenuti del canale. Sat, 07 Sep 2002 09:42:31 GMT

category Specifica una o più categorie alle quali fa parte il canale. Segue le stesse regole dell'elemento category del livello <item>. Maggiori informazioni. <category>Newspapers</category>

generator Una stringa indicante il programma usato per generare il canale. MightyInHouse Content System v2.3

docs Un URL che punta alla documentazione del formato usato per il file RSS. Probabilmente si tratterà di un collegamento a questa pagina (NdT. "questa pagina" identifica il documento orginale). L'utilità è per gli utenti che potranno incrociare un file RSS in un web server tra 25 anni che si chiederanno di cosa si tratti. http://www.rssboard.org/rss-specification

cloud Consente di registrare processi con un cloud (NdT. Servizio web che supporti l'interfaccia rssCloud) per essere notificati degli aggiornamenti del canale, implementando un protocollo leggero di pubblicazione-iscrizione per feed RSS. Maggiori informazioni qui. <cloud domain="rpc.sys.com" port="80" path="/RPC2" registerProcedure="pingMe" protocol="soap"/>

ttl ttl sta per time to live. E' il numero di minuti che indica per quanto tempo un canale può essere mantenuto in cache prima di rieseguire un aggiornamento dalla sorgente. Maggiori informazioni qui. <ttl>60</ttl>

image Specifica una immagine GIF, JPEG o PNG che può essere mostrata con il canale. Maggiori informazioni qui.

rating Il PICS per la votazione del canale.

textInput Specifica un campo input text che può essere mostrato con il canale. Maggiori informazioni qui.

skipHours Un suggerimento per gli aggregatori indicante in quali orari possono saltare la lettura. Maggiori informazioni qui.

skipDays Un suggerimento per gli aggregatori indicante in quali giorni possono saltare la lettura. Maggiori informazioni qui.

Elemento	Descrizione	Esempio
language	La lingua nella quale è scritto il canale. Questo tag consente agli aggregatori di raggruppare tutti i siti italiani, per esempio, in una singola pagina. Una lista di valori consentiti per questo elemento, così come fornita da Netscape, è disponibile qui. E' possibile usare i valori definiti dal W3C.	en-us
copyright	Informativa sul copyright per il contenuto del canale.	Copyright 2002, Spartanburg Herald-Journal
managingEditor	Indirizzo email della persona responsabile dei contenuti editoriali.	geo@herald.com (George Matesky)
webMaster	Indirizzo email della persona responsabile dei problemi tecnici relativi al canale.	betty@herald.com (Betty Guernsey)
pubDate		Sat, 07 Sep 2002 00:00:01 GMT
lastBuildDate	La data dell'ultima modifica dei contenuti del canale.	Sat, 07 Sep 2002 09:42:31 GMT
category	Specifica una o più categorie alle quali fa parte il canale. Segue le stesse regole dell'elemento category del livello `<item>`. Maggiori informazioni.	<category>Newspapers</category>
generator	Una stringa indicante il programma usato per generare il canale.	MightyInHouse Content System v2.3
docs	Un URL che punta alla documentazione del formato usato per il file RSS. Probabilmente si tratterà di un collegamento a questa pagina (NdT. "questa pagina" identifica il documento orginale). L'utilità è per gli utenti che potranno incrociare un file RSS in un web server tra 25 anni che si chiederanno di cosa si tratti.	http://www.rssboard.org/rss-specification
cloud	Consente di registrare processi con un cloud (NdT. Servizio web che supporti l'interfaccia rssCloud) per essere notificati degli aggiornamenti del canale, implementando un protocollo leggero di pubblicazione-iscrizione per feed RSS. Maggiori informazioni qui.	<cloud domain="rpc.sys.com" port="80" path="/RPC2" registerProcedure="pingMe" protocol="soap"/>
ttl	ttl sta per time to live. E' il numero di minuti che indica per quanto tempo un canale può essere mantenuto in cache prima di rieseguire un aggiornamento dalla sorgente. Maggiori informazioni qui.	<ttl>60</ttl>
image	Specifica una immagine GIF, JPEG o PNG che può essere mostrata con il canale. Maggiori informazioni qui.
rating	Il PICS per la votazione del canale.
textInput	Specifica un campo input text che può essere mostrato con il canale. Maggiori informazioni qui.
skipHours	Un suggerimento per gli aggregatori indicante in quali orari possono saltare la lettura. Maggiori informazioni qui.
skipDays	Un suggerimento per gli aggregatori indicante in quali giorni possono saltare la lettura. Maggiori informazioni qui.

<image> sub-element of <channel>

<image> è un sotto elemento opzionale di <channel>, che contiene a sua volta tre sotto elementi obbligatori e tre sotto elementi facoltativi.
<url> è l'URL di una immagine GIF, JPEG o PNG che rappresenta il canale.
<title> descrive l'immagine, è usato come contenuto dell'attributo ALT del tag HTML <img> quando il canale è rappresentato come HTML.
<link> è l'URL del sito, quando il canale è rappresentato come HTML l'immagine è un collegamento al sito. (Nota. in pratica i tag <title> e <link> dell'immagine dovrebbero avere gli stessi valori di <title> and <link> appartenenti a channel).
Gli elementi opzionali includono <width> e <height>, numeri indicanti la larghezza e l'altezza in pixel dell'immagine. <description> contiene il testo da includere come contenuto dell'attributo title del link creato attorno all'immagine in fase di rappresentazione HTML.
Il valore massimo per width è 144, quello predefinito è 88.
Il valore massimo per height è 400, quello predefinito è 31.

<cloud> sub-element of <channel>

<cloud> è un sotto elemento opzionale di <channel>.
Specifica un servizio web che supporti l'interfaccia rssCloud che può essere implementata in HTTP-POST, XML-RPC o SOAP 1.1.
Il suo scopo è consentire la registrazione di processi per essere notificati degli aggiornamenti del canale, implementando un protocollo leggero di pubblicazione-iscrizione per feed RSS.
<cloud domain="rpc.sys.com" port="80" path="/RPC2" registerProcedure="myCloud.rssPleaseNotify" protocol="xml-rpc" />
In questo esempio, per richiedere la notifica del canale riportato, è necessario inviare un messaggio XML-RPC alla porta 80 del server rpc.sys.com, con il percorso /RPC2. La procedura da richiamare è denominata myCloud.rssPleaseNotify.
Una spiegazione completa di questo elemento e dell'interfaccia rssCloud è qui.

<ttl> sub-element of <channel>

<ttl> è un sotto elemento opzionale di <channel>.
ttl sta per time to live. E' un numero di minuti che indica per quanto tempo un canale può essere mantenuto in cache prima di rieseguire un aggiornamento dalla sorgente. Questo rende possibile la gestione delle sorgenti RSS tramite un network di file sharing come Gnutella.
Esempio: <ttl>60</ttl>

<textInput> sub-element of <channel>

Un channel può contenere, facoltativamente, un sotto elemento <textInput>, che contiene a sua volta 4 sotto elementi obbligatori.
<title> -- L'etichetta del bottone di invio (NdT. campo input type submit) del modulo input text.
<description> -- Spiega il modulo input text.
<name> -- Il nome della casella di testo nel campo input text.
<link> -- L'URL dello script CGI predisposto per processare le richieste dell'input text.
Lo scopo dell'elemento <textInput> è ancora qualcosa di misterioso. E' possibile fare uso di questo tag per specificare il campo di un motore di ricerca interno. In alternativa lo si può adottare per consentire ai lettori di inviare un feedback.
La maggior parte degli aggregatori ignora questo tag.

Elementi per <item>

Un channel può contenere un qualsiasi numero di <item>.
Un item può rappresentare una "storia", come ad esempio una storia in un giornale o una rivista; in questo caso la sua descrizione è una sintesi della storia ed il collegamento indirizza alla storia completa.
Un item può anche contenere informazioni sufficienti per essere autonomo; in questo caso la descrizione contiene il testo (è ammesso un testo HTML con le entità codificate, vedi esempi) ed i tag <link> e <title> possono essere omessi.
Tutti gli elementi di un <item> sono opzionali, tuttavia deve essere almeno presente un <title> o una <description>.

Elemento Descrizione Esempio

title Il titolo di item. Venice Film Festival Tries to Quit Sinking

link L'URL di item. http://nytimes.com/2004/12/07FEST.html

description Una sintesi di item. Some of the most heated chatter at the Venice Film Festival this week was about the way that the arrival of the stars at the Palazzo del Cinema was being staged.

author Indirizzo email dell'autore di item. Approfondimento.

category Include item in una o più categorie. Approfondimento.

comments URL di una pagina contenente i commenti correlati a item. Approfondimento.

enclosure Descrive un oggetto multimediale allegato a item. Approfondimento.

guid Una stringa che identifica univocamente item. Approfondimento.

pubDate Indica quando item è stato pubblicato. Approfondimento.

source Il canale RSS dal quale proviene item. Appronfondimento.

Elemento	Descrizione	Esempio
title	Il titolo di `item`.	Venice Film Festival Tries to Quit Sinking
link	L'URL di `item`.	http://nytimes.com/2004/12/07FEST.html
description	Una sintesi di `item`.	Some of the most heated chatter at the Venice Film Festival this week was about the way that the arrival of the stars at the Palazzo del Cinema was being staged.
author	Indirizzo email dell'autore di `item`. Approfondimento.
category	Include `item` in una o più categorie. Approfondimento.
comments	URL di una pagina contenente i commenti correlati a `item`. Approfondimento.
enclosure	Descrive un oggetto multimediale allegato a `item`. Approfondimento.
guid	Una stringa che identifica univocamente `item`. Approfondimento.
pubDate	Indica quando `item` è stato pubblicato. Approfondimento.
source	Il canale RSS dal quale proviene `item`. Appronfondimento.

<source> sub-element of <item>

<source> è un sotto elemento opzionale di <item>.
Il suo valore è il nome del canale RSS da quale proviene l'item, derivato dal suo <title>. Ha un attributo obbligatorio, url, che collega alla rappresentazione XML della sorgente.
<source url="http://www.tomalak.org/links2.xml">Tomalak's Realm</source>
Lo scopo di questo elemento è di diffondere i crediti per link e di pubblicizzare le sorgenti delle news / degli elementi del feed. Può essere utilizzato nel comando Post di un aggregatore.
Dovrebbe essere generato automaticamente quando si invia un elemento da un aggregatore ad uno strumento di scrittura per blog.

<enclosure> sub-element of <item>

<enclosure> è un sotto elemento opzionale di <item>.
Ha tre attributi obbligatori. url indica doce si trova l'allegato, length indica la dimensione espressa in byte e type indica il tipo di file corrispondente ad uno dei MIME type standard.
L'url deve essere un url http.
<enclosure url="http://www.scripting.com/mp3s/weatherReportSuite.mp3" length="12216320" type="audio/mpeg" />
Un possibile scenario di con uso narrativo di questo elemento è qui.

<category> sub-element of <item>

<category> è un sotto elemento opzionale di <item>.
Ha un attributo opzionale, domain, una stringa che identifica una classificazione tassonomica per categorie.
Il valore dell'elemento è una stringa separata da slash ( / ) che identifica una collocazione gerarchica all'interno della tassonomia indicata. Gli interpreti possono stabilire convenzioni per l'interpretazione delle categorie. Due esempi sono forniti di seguito:
<category>Grateful Dead</category>
<category domain="http://www.fool.com/cusips">MSFT</category>
E' possibile includere tanti elementi category quanti siano necessari, per domini differenti, ed avere un elemento con riferimenti incrociati in diverse parti dello stesso dominio.

<pubDate> sub-element of <item>

<pubDate> è un sotto elemento opzionale di <item>.
Il suo valore è una data, corrispondente alla pubblicazione di item. Se la data fa riferimento ad un periodo futuro gli aggregatori possono scegliere di non visualizzare item fino a quella data.
<pubDate>Sun, 19 May 2002 15:21:36 GMT</pubDate>

<guid> sub-element of <item>

<guid> è un sotto elemento opzionale di <item>.
guid per Globally Inique Identifier. E' una stringa che identifica in modo univoco item.
Quando presente, l'aggregatore può scegliere di usare questa stringa per determinare se un item è nuovo.
<guid>http://some.server.com/weblogItem3207</guid>
Non ci sono regole particolari per la sintassi dell'elemento guid. Gli aggregatori devono considerarlo come stringa. Spetta alla sorgente del feed garantire l'unicità del valore della stringa.
Se l'elemento guid ha un attributo chiamato isPermalink impostato con valore true, il lettore può assumere che si tratti di un permalink all'elemento, ovvero un URL che può essere aperto in un web browser e che punta all'intero contenuto descritto dall'elemento <item>. Un esempio:
<guid isPermaLink="true">http://inessential.com/2002/09/01.php#a2</guid>
isPermalink è opzionale ed il suo valore predefinito è true. Se il suo valore è false, l'elemento guid non può essere considerato un URL o un indirizzo a qualcosa in particolare.

<comments> sub-element of <item>

<comments> è un sotto elemento opzionale di <item>.
Se presente, corrisponde all'URL della pagina contenente i commenti a item.
<comments>http://ekzemplo.com/entry/4403/comments</comments>
Maggiori informazioni sui commenti qui.

<author> sub-element of <item>

<author> è un sotto elemento opzionale di <item>.
Corrisponde all'indirizzo email dell'autore di item. Per i giornali e le riviste che distribuiscono un feed RSS, l'autore è la persona che ha scritto l'articolo che item descrive. For blog composti da più collaboratori, l'autore di item potrebbe essere differente dall'editore responsabile (managin editor) o dal webmaster. Per un blog gestito da un singolo individuo avrebbe senso omettere l'elemento <author>.

Commenti

L'RSS imposta delle restrizioni al primo carattere non spazio e non bianco che compone il valore degli elementi <link> e <url>. Il valore di questi elementi deve cominciare con uno schema URI IANA-registrato, come ad esempio http://, https://, news://, mailto:// e ftp://. Prima del formato RSS 2.0 le specifiche consentivano solo http:// e ftp://, tuttavia, in pratica gli altri schemi URI erano ugualmente usati dagli sviluppatori e supportati dagli aggregatori. Gli aggregatori possono avere dei limiti per quanto riguarda il supporto a schemi URI. Gli sviluppatori di contenuti non dovrebbero dare per scontato che ogni lettore per feed supporti tutti gli schemi.
Nell'RSS 0.91, molti elementi sono limitati a 500 o 100 caratteri. Non ci possono essere più di 15 <items> in un <channel> nel formato 0.91. Non ci sono limiti di lunghezza per le stringhe o limiti a livelli XML nell'RSS 0.92 e superiori. Gli interpreti possono imporre limiti specifici e i produttori di contenuti possono avere preferenze sul numero massimo di <item> che desiderano inserire in un channel, o quali stringhe devono avere limiti di lunghezza.
Nell'RSS 2.0 c'è un modo per collegare un canale al suo identificatore in un sistema di catalogazione usando la funzionalità dell'elemento category a livello channel, come descritto in precedenza. Per esempio, per collegare un canale al suo identificatore in Syndic8, basta includere un elemento category come sub-elemento di <channel>, con dominio "Syndic8" e come valore l'identificativo per il canale nel database di Syndic8. L'elemento category appropriato per Scripting News dovrebbe essere <category domain="Syndic8">1765</category>.
Una domanda frequente per quanto riguarda gli elementi <guid> è se/come possano essere comparati agli elementi <link>. Non sono la stessa cosa? Sì, in alcuni sistemi di contenuti, e no in altri. In alcuni sistemi, <link> è un permalink ad un post di un blog. Tuttavia, in altri sistemi, ogni <item> è un riassunto di un articolo più lungo, <link> punta all'articolo e <guid> è il permalink al post del blog.
In ogni caso, è consigliato fornire un guid e se possibile renderlo un permalink. Questo consente agli aggregatori di evitare la ripetizione di item, anche se è stato modificato o sono stati apportati cambiamenti.
Se avete domande sul formato RSS 2.0, siete invitati a postarle nella mailing list pubblica RSS-Public. La mailing list, gestita dall'RSS Advisory Board, serve come risorsa di supporto per utenti, autori e sviluppatori alle prese con la creazione e l'uso di contenuti nel formato RSS 2.0.

Estendere l'RSS

L'RSS ha avuto origine nel 1999 e si è sforzato di essere un formato semplice, facile da comprendere con obiettivi relativamente modesti. Dopo essere diventato un formato popolare, gli sviluppatori hanno desiderato estenderlo attraverso moduli definiti via namespace, così come specificato dal W3C.
RSS 2.0 introduce questa possibilità, seguendo una semplice regola. Un feed RSS può contenere elementi non descritti in questa pagina solo se questi elementi sono definiti in un namespace.
Gli stessi elementi definiti in questo documenti non parte di un namespace, così che l'RSS 2.0 risulti compatibile con versioni precedenti in questo senso -- un file in versione 0.91 o 0.92 è anche un file 2.0 valido. Se gli elementi di un RSS 2.0 fossero stati inseriti in un namespace, questa restrizione sarebbe venuta meno, un file in versione 0.9x non sarebbe stato un file 2.0 valido.

Roadmap

RSS non è in alcun modo un formato perfetto, ma è molto diffuso e largamente supportato. Disporre di una specifica stabile è qualcosa che l'RSS necessitava da molto tempo. Lo scopo di questo lavoro è di aiutare il formato a diventare un qualcosa di definito, garantirne la crescita nel mercato che si sta sviluppando attorno e di spianare la strada per innovazioni in nuovi formati di distribuzione. Perciò, le specifiche RSS, per necessità pratiche, sono bloccate alla versione 2.0.1. Anticipiamo la possibilità di versioni 2.0.2 o 2.0.3, ecc unicamente con lo scopo di chiarire ulteriormente le specifiche, non per aggiungere nuove funzionalità al formato. Lavori successivi dovrebbero concretizzarsi in moduli, attraverso l'uso di namespace, ed in formati di distribuzione completamente nuovi, con nuovi nomi.

Utilizzare hastable in javascript

2011-05-02T08:05:00.000-07:00

In JavaScript non abbiamo alcun built-in hashtable. Ma hashtable è una struttura molto utile dato che spesso ne abbiamo bisogno. Anche se non abbiamo hashtable in JavaScript, è davvero molto semplice implementare una hashtable in JavaScript. In questo post, implementiamo un semplice hashtable. Sicuramente non useremo alcun loop per cercare gli articoli. Perché, in tal caso il vero scopo della hashtable non sarà ottenuto. In JavaScript, è possibile utilizzare la proprietà oggetto per ottenere l'oggetto Hashtable.
Prima di tutto vediamo i principi fondamentali dell'oggetto JavaScript e proprietà dell'oggetto.
Dichiarazione di un oggetto JavaScript:

Ci sono vie alternative di creazione di un oggetto JavaScript. Il più semplice è il seguente:

var HashTable = {};

Questo crea un oggetto semplice javascript che non ha proprietà. Possiamo anche creare un nuovo oggetto usando javascript.

var = HashTable new Object ();

Creazione di una proprietà di un oggetto:

Siamo in grado di creare una proprietà di un oggetto esistente come segue:

hashTable.id = 1;

hashTable.name = 'a hashtable' ;

Qui abbiamo due proprietà. Possiamo anche avere proprietà che sono una funzione.

hashTable.SetItem = function(chiave, valore) {

; / / implementare hashtable voce qui impostato sulla base di chiave

}

hashTable.GetItem = function(key) {

; / / implementare hashtable ottenere elemento chiave da qui

}

Accesso Javascript oggetto di proprietà:
E 'molto semplice capire che siamo in grado di accedere a una proprietà di un oggetto JavaScript, semplicemente utilizzando. Property_name.

hashTable.name

Ma c'è un altro modo di accedere alla proprietà.

hashTable['name']

hashTable['id']

hashTable['SetItem'](‘akey’, ‘aValue’);

hashTable['GetItem'](‘akey’));

Il vantaggio di utilizzare questo approccio, possiamo usare come variabile l'indice. Così possiamo accedere alle proprietà dinamicamente in base alle variabili.
Implementazione HashTable:

Ora siamo in grado di generare facilmente Hashtable utilizzando le conoscenze di cui sopra.

var hashTable = {};

hashTable.SetItem = function(key, value) {

hashTable[key] = value;

}

hashTable.GetItem = function(key) {

return hashTable[key];

}

hashTable.SetItem(‘aKey’, ‘aValue’);

alert(hashTable.GetItem(‘aKey’));

Creazione di una classe Hashtable:

Usando il modo di cui sopra, non saremo in grado di utilizzare più hashtable, se abbiamo bisogno. Così possiamo creare una classe javascript hashtable.

function HashTable() {

var hashTableItems = {};

this.SetItem = function(key, value) {

hashTableItems[key] = value;

}

this.GetItem = function(key) {

return hashTableItems[key];

}

Possiamo usare la hashtable come segue:

var hashTable = new HashTable();

hashTable.SetItem(‘aKey’, ‘aValue’);

alert(hashTable.GetItem(‘aKey’));

var hashTable_new = new HashTable();

hashTable_new.SetItem(‘anotherKey’, ‘anotherValue’);

alert(hashTable_new.GetItem(‘anotherKey’));

Come Creare Un Blog

2011-04-12T09:39:00.001-07:00

Come Creare Un Blog: Le Migliori Piattaforme di Pubblicazione Online Gratuite

WordPress

WordPress è il servizio più famoso in assoluto sul Web per creare un blog. Wordpress è altamente personalizzabile grazie all'impressionante numero di funzioni aggiuntive e template utilizzabili. WordPress consente di utilizzare filtri anti-spam di qualità, feed RSS, effettuare statistiche in tempo reale sul traffico. WordPress possiede un'attivissima community di supporto pronta ad aiutarti per risolvere qualsiasi tipo di problema. Inoltre, WordPress, se hai bisogno di creare un blog privo di annunci pubblicitari, un dominio personalizzato, esportare i contenuti del tuo blog o utilizzare le impostazioni avanzate per la privacy, ti mette a disposizione le premium features, funzioni avanzate attivabili sottoscrivendo un account a pagamento. I prezzi sono consultabili sul sito web.

WordPress
Blogger

Blogger è un servizio gratuito di Google che ti permette di creare il tuo blog personale. Blogger funziona con i tuoi dati di accesso a Google ed è totalmente integrato con altri servizi del motore di ricerca come AdSense e Analytics, che ti permettono di monetizzare il tuo blog e controllare le statistiche sul traffico. Blogger supporta anche l'opzione multi-autore, i feed RSS, diverse funzionalità per la personalizzazione del template, la pubblicazione tramite cellulare e le impostazioni per la privacy. Blogger possiede anche una vasta comunità degli utenti a cui ti puoi rivolgere per ricevere aiuti per qualsiasi tipo di problema. Blogger, però, non supporta i domini personalizzati. Non esistono account premium: tutte le funzionalità sono disponibili gratuitamente.

Blogger
Windows Live Spaces

Windows Live Spaces è un servizio di Microsoft che ti permette di creare blog. Windows Live Spaces ti permette di accedere alle funzionalità di creazione del blog con il tuo Windows LiveID e di integrare all'interno del blog i contenuti che hai pubblicato su altri servizi di Microsoft, come ad esempio SkyDrive. Windows Live Spaces organizza il tuo blog, chiamato anche "Space", in moduli che puoi spostare in qualsiasi punto della tua pagina web. Windows Live Spaces non ha la personalizzazione del CSS o dell'HTML, ma ti consente di modificare le impostazioni sulla privacy, pubblicare tramite cellulare e usufruire di un servizio limitato di statistiche sul traffico. Windows Live Spaces non ti consente di scegliere un dominio personalizzato o esportare i tuoi contenuti verso un'altra piattaforma. La Live community offre un ottimo supporto a qualunque esigenza tu possa avere durante la creazione del tuo nuovo blog. Non sono disponibili account a pagamento.

Windows Live Spaces
LiveJournal

LiveJournal è una comunità virtuale all'interno della quale gli utenti registrati possono creare un blog gratuito e ricevere aiuti dagli altri utenti in qualsiasi momento. LiveJournal ti consente di costruire il tuo elenco di amici e leggere i loro aggiornamenti (e/o permettere che loro leggano i tuoi) attraverso un feed RSS. LiveJournal ti mette a disposizione anche un account a pagamento che ti consente di accedere a una serie di funzioni avanzate, tra le quali funzioni sulla privacy, per impostare quali utenti potranno accedere al tuo blog, la possibilità di esportare il tuo blog verso un'altra piattaforma di pubblicazione online, l'opzione "phone to blog", che ti permette di postare direttamente dal tuo cellulare. LiveJournal non consente di utilizzare statistiche sul traffico e domini personalizzati.

LiveJournal
Vox

Vox è una piattaforma di pubblicazione online per creare blog. Vox è prodotto da Six Apart (l'azienda che produce anche la piattaforma di blogging MovableType). Vox necessita solo dei tuoi dati di registrazione, inseriti i quali potrai iniziare immediatamente a creare il tuo blog con pochi semplici passaggi: dovrai semplicemente selezionare il template che vuoi utilizzare da una libreria di modelli, aggiungere i tuoi contenuti (testi, video, immagini, tracce audio), impostare le opzioni per la privacy. Vox possiede una funzionalità di integrazione del tuo blog con i siti di video e photo sharing come YouTube e Flickr. Vox non consente di acquistare account premium, di pubblicare tramite cellulare o personalizzare il nome del tuo dominio. Il solido servizio clienti è sempre a tua disposizione per risolvere tutti i possibili problemi.

Vox
Xanga

Xanga è una piattaforma di pubblicazione online gratuita per la creazione di blog. Xanga, dopo aver effettuato la registrazione, ti consente di personalizzare il layout del tuo blog con uno dei tanti template disponibili, di impostare il livello di protezione dei contenuti pubblicati, scegliendo gli utenti che avranno accesso ai tuoi post. Xanga non mette a disposizione nessuna funzione per effettuare le statistiche sul traffico, la pubblicazione tramite cellulare e la personalizzazione del nome del dominio. Xanga si avvale del supporto di una comunità, molto utile per risolvere i diversi problemi che si possono incontrare durante la creazione e la gestione di un blog. Xanga consente di acquistare account premium con maggiori funzionalità a partire da $4 al mese.

Xanga
Tripod

Tripod è un servizio online che puoi utilizzare per creare gratuitamente un blog e distribuirlo tramite feed RSS. Tripod, se già possiedi un account Lycos, ti permette di iniziare subito a gestire il tuo blog online.Tripod non ti consente di avere statistiche sul traffico, di effettuare la pubblicazione tramite cellulare, di eseguire l'esportazione dei contenuti o di utilizzare impostazioni avanzate per la privacy. Tripod ha un forum di supporto abbastanza limitato, ma ti consente di accedere a altre funzionalità avanzate (come la creazione dei domini personalizzati) mediante degli account a pagamento, disponibili a partire dai $4.95 al mese.

Tripod
Blog.com

Blog.com è un servizio gratuito che ti permette di creare il tuo blog personale. Blog.com, dopo una semplice registrazione, ti consente immediatamente di creare un blog che potrai distribuire via feed RSS o Atom (un altro sistema per la sottoscrizione di contenuti web). Blog.com ti permette di acquistare un account premium a partire da 4.95 dollari al mese, che ti consentirà di utilizzare le funzionalità avanzate come le impostazioni della privacy, la personalizzazione del CSS, ecc. Blog.com non offre statistiche sul traffico, i domini personalizzati, l'esportazione dei contenuti o la possibilità di postare tramite cellulare.

Blog.com
Yahoo! Pulse

Yahoo! Pulse è un servizio gratuito che ti permette di creare il tuo blog personale. Yahoo! Pulse, una volta effettuato il login utilizzando i dati di accesso del tuo account Yahoo! (se non ne possiedi uno lo puoi creare direttamente dal sito di Yahoo! Pulse), ti consente di selezionare i colori del tuo blog, impostare le opzioni per la privacy, condividere i tuoi contenuti (puoi utilizzare anche i feed RSS). Yahoo! Pulse ti permette di postare dal tuo cellulare utilizzando l'opzione Yahoo! Mobile. Yahoo! Pulse non offre account premium, la personalizzazione dei domini e nemmeno le statistiche sul traffico. Yahoo! Pulse si avvale di un buon supporto offerto dalla communityy di Yahoo!.

Yahoo! Pulse
Blogr

Blogr è un servizio gratuito per creare il tuo blog e a condividere i tuoi contenuti sul Web. Blogr ha un'interfaccia davvero intuitiva mediante la quale puoi pubblicare testi, foto e video in maniera semplice. Blogr ti consente di organizzare i tuoi contenuti utilizzando uno dei template disponibili e distribuirli tramite feed RSS. Blogr non supporta le statistiche sul traffico, la pubblicazione tramite cellulare, le impostazioni della privacy e i domini personalizzati. Buono il supporto del forum per far fronte a tutti i problemi derivanti dall'utilizzo di Blogr.

Blogr
Squarespace

Squarespace è una piattaforma di pubblicazione on line a pagamento per creare blog. Squarespace, grazie alla sua interfaccia davvero semplice, ti consente di modificare, impostare e persino trascinare gli elementi del tuo layout all'interno della pagina web senza alcuna conoscenza tecnica. Squarespace ti mette a disposizione opzioni per la privacy, statistiche per il traffico, i feed RSS e tutorial che ti spiegano come iniziare a bloggare in pochi passi. Squarespace non supporta la pubblicazione tramite cellulare. Squarespace può essere provato gratuitamente per 14 giorni, trascorsi i quali è necessario acquistare uno degli account a pagamento (a partire da $8 al mese) che ti consentono di accedere ad una serie di funzioni aggiuntive, tra le quali quelle per la personalizzazione del nome del tuo dominio e di ricevere supporto dal servizio clienti dedicato.

Squarespace
TypePad

TypePad è una piattaforma di pubblicazione online a pagamento, che ti aiuta a creare il tuo blog in maniera del tutto semplice. TypePad possiede centinaia di template che ti permettono di personalizzare l'aspetto del tuo blog. TypePad ti consente di effettuare la pubblicazione tramite cellulare e tramite Facebook, utilizzare i feed RSS, effettuare statistiche sul traffico, attivare filtri anti-spam, gestire gli annunci, ecc. TypePad non ti permette di esportare il tuo blog verso un'altra piattaforma. TypePad può essere provato gratuitamente per 14 giorni, trascorsi i quali, per continuare ad utilizzarlo, è necessario scegliere uno dei piani tariffari, disponibili a partire da $4.95 al mese.

TypePad
DBlog

DBlog è una piattaforma di pubblicazione online opensource per creare blog. DBlog è sia un weblog sia un photoblog, permette cioè la pubblicazione sia di articoli sia di fotografie, organizzate in due aree differenti. DBlog consente di sfruttare i feed RSS, utilizzare filtri per il contenuto del testo degli articoli in modo da eliminare parole e termini indesiderati, gestire la classifiche degli articoli e delle fotografie più visitate, ecc.

DBlog
Blog:CMS

Blog:CMS è una piattaforma di pubblicazione online gratuita per creare blog. Blog:CMS integra le funzioni per realizzare e gestire weblog, fotogallery, forum, news. Blog:CMS è ottimizzato per funzionare sui più recenti browser, come Firefox, Safari, Opera, ecc. Blog:CMS attualmente non è disponibile in lingua italiana.

Blog:CMS

Questo-è-un-blog-sulla-SEO

2011-04-12T06:52:00.000-07:00

Subscribe:

Friday, January 14, 2011

Ranking factors: Elementi che determinano la posizione su Google

A cosa prestare massima attenzione per salire nei motori di ricerca? SeoMoz sta stilando una classifica dei principali ranking factors ( fattori di ranking) e non fa mai male ripeterli e trovarne di nuovi. Subito dopo meta title, description e parole chiave nel testo, troviamo proprio l’algoritmo LDA per la coerenza semantica del testo che mi sta tanto a cuore.

Questi sono i fattori on page che chiunque voglia lanciare un business online deve tenere presente se vuole comparire nelle prima posizioni di Google. Se non sapete a cosa si riferiscono questi termini, vi consiglio di leggere SEO Power di Giorgio Taverniti che spiega in maniera semplice e sintetica il significato di tutti questi ranking factors.

1)Parola chiave nel titolo, Prima parola chiave nel titolo ,Parola chiave nel titolo 2X, Parola chiave nel titolo 3X+,

2)Parola chiave nell’ H1, La prima parola chiave in H1,Parola chiave in H1 2X, Parola Chiave in H1 3X+, Parola chiave in H(x) (2+)

3)Parola chiave nell’URL, Parola chiave tra le Meta Keywords, Parola chiave nel Meta Description, Parola chiave nel Meta Tag (non Description/Keyword)

4)Parola chiave tra le prime 10 parole nella pagina ,Parola chiave tra le prime 100 parole nella pagina, Parola chiave tra le prime 500 parole nella pagina, TF*IDF, Densità di parole chiave, # di ripetizioni della parola chiave

5)LDA sul contenuto, LDA nel titolo

6) Numero di parole del contenuto, Numero di caratteri, Livello di lettura del documento,

7)# numero di immagini nel documento, # di immagini >30x30px nel documento, # di link interni al documento, # di link esterni al documento, # di dofollow link interni nel documento, # di dofollow link esterni nel documento, # di link interni nofollow nel documento, # di link esterni no follow nei documento, # totale di links nel documento, # totale di links dofollow nel documento, # totale di links no follow nel documento, # totale di link esterni DA 80+ domini, # totale di link esterni DA <40 Domains, # totale di link esterni DmT 6+ Domains, # totale di link esterni DmT <3 Domains, # più alto di link esterni per ogni singolo dominio,Presenza di link alla Privacy Policy sulla pagina

8)Grandezza della pagina in KB,Velocità di download ,Presenza di contenuto video, Presenza di External iFrame, Presenza di Internal iFrame

9) Presenza della data,(se esiste la data) quanto è recente

10) Presenza di AdSense nella pagina, Presenza di Annunci di Microsoft Powered Ads sulla pagina, Presenza di Google Ad Network Powered Ads sulla pagina

11)Versione HTML/XHTML in Markup, W3C Code Validation, # di errori secondo W3C Code Validation, Presenza di tabelle in HTML

12)Presenza di un link ad un account twitter,Presennza di un link ad un account facebook, Presenza di un link verso una pagina *.Google.com, Presenza di un link verso una pagina*.Microsoft.com

13) Presenza di linguaggio per adulti o scurrile

14) Caratteri presenti nell’URL , Numeri di slash nella URL (folder depth), Uso del trattino nella URL, Uso di underscore nell’ URL, http vs. https, presenza di ?= nella stringa dell’URL, presenza di 2+ ?= nella stringa dell’URL, Presenza di Rel=Canonical sulla pagina

15) Se la pagina è l’homepage,Se la pagina ha >100 di link dofollow, Se la pagina ha >100 di link in totale, Se la pagina ha>300 di link dofollowed, Se la pagina ha >300 di link totali, Se il breadcrumb viene mostrato nelle SERP di Google (solo l’ URL)

16)Se la pagina è https (secure server), Se l’url contiene "www", Se si usa piattaforma wordpress, Se si usa piattaforma Tumblr/Posterous/Blogger/Typepad/etc.

SEOmoz chiede l'aiuto di tutti i SEO per stilare una lista ancora più ricca per il 2011. Tenete sotto controllo il sito!

Come disattivare la cache di Firefox?

2011-04-06T00:23:00.000-07:00

Come disattivare la cache di Firefox?

È possibile forzare tutte le richieste relative ad un aggiornamento per essere effettivamente richiesto dal server (aggirando qualsiasi tipo di contenuto già nella cache, e l'aggiornamento della cache con la nuova versione) utilizzando Ctrl + F5 invece di F5.
Questo non funziona per le richieste effettuate tramite la pagina all'interno di codice sul lato client . Quando questo è un problema è necessario utilizzare il metodo POST (richieste POST non dovrebbero mai essere messi in cache), invece di GET o aggiungere un valore in continua evoluzione per la querystring (come ad esempio l'ora attuale in ms)

Disattivare la cache di una pagina particolare. il modo corretto è quello di impostare la direttiva cache nella richiesta Http:

Cache-Control: no-cache

attivare la capacità di Firefox intera cache off attraverso la sua pagina

about: config network.http.use-cache = false.

Direi che il modo migliore che ho trovato è fare clic su Strumenti di 
Firefox e iniziare la navigazione privata che non cache le pagine e 
ripristinare tutte le pagine che erano aperte prima di andare a 
Navigazione privata.  Nizza funzionalità.

Gli eseguibili di PostgreSQL

2011-03-04T02:46:00.000-08:00

Gli eseguibili di PostgreSQL

Le locazioni degli eseguibili di PostgreSQL cambiano in funzione della modalità di installazione e del sistema operativo scelto per ospitarlo.

Nel caso di un’installazione binaria su sistema debian questi vengono posizionati nella directory /usr/bin.

Nel caso di un’installazione da sorgenti, se il configure è stato lanciato senza specificare il PREFIX allora gli eseguibili vengono posizionati nella directory /usr/local/pgsql/bin.

In questo caso particolare, la directory /usr/local/pgsql ospita l’intera struttura di eseguibili, documentazione, librerie ed eventuali moduli contrib.

Pertanto il percorso degli eseguibili, per maggiore comodità d’uso da riga di comando, va aggiunto al PATH del nostro sistema.

In genere si preferisce editare il file /etc/profile per avere una mappatura automatica oppure, se non si ha accesso come utente root al sistema si può modificare il file .bash_profile della home dell’utente postgres.

Sui sistemi windows invece l’installazione crea nella cartella c:postgresPostgreSQLXXX l’intera struttura con directory bin contenente gli eseguibili e Data contenente il cluster, se questi è stato creato contestualmente all’installazione.

Passiamo quindi ad analizzarli nel dettaglio.

postgres

postgres è il server PostgreSQL.

Ogni volta che un client si collega, in maniera locale oppure via tcp, l’istanza postgres avvia un nuovo processo server che prende in carico la connessione.

È possibile avere solo un’istanza postgres per un database cluster.

Questi è una directory dedicata, chiamata normalmente «data area», che contiene tutti i database associati all’instanza postgres.

E possibile avere più istanze postgres sullo stesso sistema a patto di avere data area differenziate e porte d’ascolto TCP diverse.

Quando postgres viene lanciato, come comando oppure con pg_ctl, deve conoscere la posizione della data area.

Il parametro da riga di comando -D oppure la variabile d’ambiente PGDATA devono quindi essere definite affinchè postmaster possa partire.

Per ragioni puramente pratiche è preferibile definire PGDATA al momento del login utente in modo da rendere disponibile questa informazione a postgres e ai programmi che devono conoscere la posizione della data area, come initdb e pg_ctl.

Per ragioni storiche è presente l’alias postmaster che punta all’eseguibile postgres

psql

psql è il terminale interattivo di PostgreSQL.

Permette di inviare query in modalità interattiva, permette di salvare l’output su file e di leggere file sql.

Per tale motivo è lo strumento principale per il restore da dump sql.

Se viene ricompilato con le funzionalità readline permette di lavorare in maniera del tutto simile alla bash.

clusterdb

L’eseguibile clusterdb è un wrapper per il comando SQL CLUSTER.

Semplicemente opera un recluster di tutte le tabelle nel database bersaglio.

È possibile specificare quale tabella sottoporre a clusterizzazione.

createdb

createdb crea un nuovo database nel cluster.

L’eseguibile e’ un wrapper per il comando SQL CREATE DATABASE

L’utente di database che esegue il comando diventa l’owner del nuovo database.

È possibile specificare un owner diverso con l’opzione -O.

createlang

createlang crea un nuovo linguaggio nel database bersaglio.

L’eseguibile e’ un wrapper per il comando SQL CREATE LANGUAGE

createuser

createuser crea un nuovo ruolo utente nel cluster PostgreSQL.

Solo gli utenti con la grant CREATEROLE possono creare nuovi utenti.

createuser è un wrapper per il comando SQL CREATE ROLE .

dropdb

dropdb distrugge un database presente nel cluster PostgreSQL.

L’utente per eseguire il comando dropdb deve essere superutente oppure owner del database da cancellare.

dropdb è un wrapper SQL del comando DROP DATABASE.

droplang

droplang elimina un linguaggio procedurale nel database bersaglio.

È consigliabile adoperare droplang per la cancellazione poiché questo comando esegue una serie di controlli che altrimenti andrebbero fatti a mano.

dropuser

dropuser è un wrapper da riga di comando per il comando SQL DROP USER.

ecpg

ecpg è il preprocessore C con comandi SQL embedded.

Sostanzialmente converte i programmi scritti in C aventi comandi SQL in codice C sostituendo ai comandi SQL chiamate a funzioni specifiche per l’elaborazione SQL.

Il file sorgente prodotto da ecpg può essere elaborato da un qualsiasi compilatore C.

ecpg trasforma qualsiasi file specificato dalla riga di comando nel corrispondente nome file con estensione .c .

L’estensione di input preferita da ecpg è .pgc a indicare che si tratta di file specifici per l’ecpg.

Qualora il file avesse estensione diversa da .pgc allora ecpg produce un file di output con l’intero nome file, comprensivo di estensione, con l’aggiunta di .c in fondo.

Il nome del file di output può essere specificato usando l’opzione -o.

initdb

initdb crea un nuovo cluster PostgreSQL.

Un cluster è una collezione di database gestiti da una singola istanza server.

Il programma produce, in una directory specifica, che può essere indicata da riga di comando oppure attraverso la variabile d’ambiente PGDATA, una serie di sottodirectory.

La struttura di queste directory le vedremo in dettaglio nel capitolo 10.

La creazione del cluster genera il catalogo di sistema, le directory che andranno ad ospitare i file specifici dell’istanza PostgreSQL e i due database template0 e template1.

Il database template0 è il database master di template1 ed ha la peculiarità di non essere accedibile in alcun modo.

Il database template1 viene prodotto copiando template0 su di una nuova directory oggetto e da questi, dalla versione 8.1 in poi, viene generato il database postgres.

Ogni volta che si va a generare un nuovo database con il comando createdb o con CREATE DATABASE, se non viene indicato il template di partenza allora viene adoperato template1 come master per la creazione.

È quindi consigliato apportare le modifiche che si vogliono propagare ai nuovi database, come ad esempio un linguaggio procedurale specifico, al template1 prima di iniziare a creare nuovi database.

Ovviamente le modifiche fatte a template1 si propagano solo ai nuovi database, quelli già presenti vanno editati a mano.

inidb deve essere lanciato con l’utente di sistema che andrà a gestire il processo postgres.

Inoltre iniddb inizializza il default locale e character set encoding del cluster database.

La collation order e il character set sono fissi e non possono essere modificati.

Ordini di collation diversi da C e POSIX possono dare decadimenti di performance.

Diventa quindi strategico scegliere il locale corretto prima di lanciare initdb.

Un diverso character set può essere definito durante la creazione di un nuovo database con l’opzione –encoding di createdb oppure con la clausola ENCODING del corrispondente comando SQL.

ipcclean

ipcclean rimuove tutti i segmenti di memoria condivisa e i semafori dell’utente di sistema che lancia il comando.

Il suo utilizzo è specifico quando avviene un crash di istanza per ripulire la memoria.

Considerato che il rilancio del server effettua una pulizia della memoria, questo comando è abbastanza inutile.

Lanciare questo comando con il server in esecuzione provoca la deallocazione di tutta la memoria condivisa dal processo postgres con serie conseguenze sul server.

pg_config

L’utilità pg_config stampa a video i parametri di configurazione della versione installata di PostgreSQL.

Viene utilizzato per determinare la posizione dei file di header e delle librerie.

pg_controldata

pg_controldata stampa a video le informazioni del processo di inizializzazione del cluster fatto da initdb come versione del catalogo e il locale del server.

Oltre a queste informazioni vengono estratti dati specifici relativi al cluster come ad esempio lo stato dei WAL ed i checkpoint.

pg_ctl

pg_ctl è l’utilità specifica per l’avvio, l’arresto il rilancio e il ricaricamento del server PostgreSQL.

Permette inoltre di interrogare lo status del server in esercizio.

Il suo utilizzo è da preferirsi al lancio manuale del comando postgres in quanto ha delle opzioni specifiche per lo shutdown controllato del server.

pg_dump

pg_dump è lo strumento principale per il backup dei database PostgreSQL.

Esegue backup consistenti all’istante di lancio del comando anche se il cluster è acceduto da più client.

pg_dump, a parte l’overhead sul server, non blocca la normale attività del cluster e può essere lanciato senza rischi di blocchi.

I backup possono essere effettuati sia in formato testo, semplici comandi SQL che vanno a ricreare oggetti e dati, che in formato binario compresso e non.

Il restore dei file di testo avviene con l’invio di questi file al comando psql mentre per il restore dei file binari è necessaria l’utilità pg_restore.

pg_dumpall

pg_dumpall è un wrapper per pg_dump che esegue il backup di tutti i database del cluster su cui è lanciato.

pg_resetxlog

pg_resetxlog rimuove i WAL dalla directory pg_xlog ed eventualmente resetta le informazioni di controllo memorizzate nel file pg_control.

Questo comando va considerato alla stregua di ultima spiaggia in caso di corruzione dei WAL in quanto il reset di questi file cancella ogni riferimento consistente tra i dati disco e lo stato delle transazioni.

In caso di utilizzo di pg_resetxlog una volta riavviata l’istanza va immediatamente eseguito un dump del cluster nella sua interezza con pg_dump, reinizializzato un nuovo cluster con initdb sul quale va reimportato il dump.

Per ragioni di sicurezza pg_resetxlog non accetta la variabile d’ambiente PGDATA ma richiede l’indicazione da riga di comando della directory data.

pg_restore

pg_restore serve a importare un database PostgreSQL esportato in maniera binaria da pg_dump.

reindexdb

reindexdb è un wrapper per il comando SQL REINDEX che effettua la ricostruzione degli indici in un database PostgreSQL.

vacuumdb

vacuumdb è un wrapper per il comando VACUUM che opera il vacuum sui database PostgreSQL.

Linux copie

2011-03-04T01:05:00.000-08:00

 Il comando di copia è pg_dump che dovrebbe trovarsi in /usr/bin

Il pg_dump

L’esecuzione del comando pg_dump non fa altro che aprire un nuovo backend verso il database server e interrogare il catalogo di sistema per andare a costruire le DDL e l’export dei dati che poi andranno a finire nel file di output.

L’operazione avviene come di consueto attraverso una transazione che rispetterà le regole di isolamento delle transazioni presenti in PostgreSQL.

pg_dump una volta invocato, fatti i debiti controlli sui parametri e una volta connesso al database server esegue il seguente comando:

BEGIN;

SET TRANSACTION ISOLATION LEVEL SERIALIZABLE;

In questo modo apre esplicitamente una transazione e impone il massimo livello di isolamento delle transazioni per il suo backend vincolando il cluster a garantirgli la consistenza in lettura senza nessun compromesso.

Successivamente, come si legge dal sorgente pg_dump.c, esegue una serie di query sul catalogo di sistema per generare le tabelle interessate dal dump e infine, se previsto dai parametri, i dati.

È interessante osservare come l’elaborazione e la costruzione del file di dump sia alquanto “furba“.

Infatti la parte più onerosa durante la fase di restore, la creazione delle primary keys e gli indici, viene tenuta per ultima.

Inoltre di default per il caricamento dei dati viene adoperato il comando copy che, a differenza delle insert, attraversa gli stage dell’esecuzione di una query soltanto una volta velocizzando notevolmente il processo di caricamento.

pg_dump -v -f /var/newstar/copie -U newstar -Fc newstar

-v verbose

-f file di backup in output

-U user

-Fc formato compresso e utilizzabile per restore (consigliato)

Notepad per php con debugger

2011-02-28T07:31:00.000-08:00

Debuggare pagine PHP con Notepad

1)scaricare plugin
Scaricare il plugin DBGpPlugin_0_12b_dll.zip o versioni equivalenti.
Una volta scaricato ed installato il plugin per l'editor (cosa che consiste nel copiare la dll contenuta nel pacchetto zip del plugin, nella cartella "plugins" nel percorso di installazione del Notepad++), siamo pronti ad attrezzare la nostra installazione di PHP dei moduli necessari per il debug.
2) installare Xdebug
Il modulo in questione è il modulo XDebug. Anche in questo caso l'installazione risulta poco complessa. L'unica particolarità risiede nel fatto che si deve installare la versione del debugger compilata ad-hoc per la versione di PHP presente sul sistema per il debug.

Una volta scaricato il modulo corrispondente alla nostra versione del PHP, lo si può copiare nella cartella ext di PHP o direttamente sotto la radice di PHP stesso.
Per permettere la gestione del modulo da parte di PHP è necessario aprire il file PHP.ini presente nella cartella di installazione del PHP e aggiungere le seguenti righe di configurazione:

#zend_extension_ts="Drive:/percorso/verso/il/modulo/xdebug/php_xdebug-2.0.5-5.2.dll"
zend_extension="C:\xampp\php\ext\php_xdebug.dll"

xdebug.profiler_append=1
xdebug.profiler_enable=0
xdebug.profiler_enable_trigger=0
xdebug.profiler_output_dir=
xdebug.profiler_output_name=cachegrind.out
xdebug.remote_enable=on
xdebug.remote_handler=dbgp
xdebug.remote_host=localhost
xdebug.remote_port=9000
xdebug.trace_output_dir="C:\xampp\tmp"
zend_extension_ts=C:\xampp\php\ext\php_xdebug.dll
xdebug.default_enable=On
xdebug.remote_log=
xdebug.remote_mode=req
xdebug.idekey=devphp

3) verificare php
A questo punto, se abbiamo scelto il modulo giusto per la nostra versione di PHP, il debugger dobrebbe essere integrato. Si può verificare l'installazione del modulo controllando l'output della funzione phpinfo() che dovrebbe riportare una sezione relativa a xdebug.
4)eseguire
A questo punto dovrebbero sussistere tutti i presupposti per poter eseguire il debug degli script PHP.
Aprire quindi con il notepad++ il file all'interno dello spazio web gestito da Apache che vogliamo debuggare e attivare il plugin del debugger selezionandolo dall'apposito menu (plugins -> DBGp -> Debugger).
Portandoci su una riga di codice PHP, possiamo inserirvi un breakpoint, clickando sul pallino rosso, in modo che l'esecuzione dello script si fermi su quella linea.
Per lanciare l'esecuzione dello script, aprire un browser internet e digitare il percorso della pagina da debuggare sul server locale.
In fondo al percorso alla pagina all'interno del browser web, dobbiamo aggiungere un parametro get che permetta la definizione del nome di una sessione di debug.

Ecco un esempio di percorso alla pagina da debuggare con la formattazione necessaria:

http://localhost/pagDaDebuggare.php?XDEBUG_SESSION_START=NomeSessione
Il nome della sessione può essere del tutto arbitrario. A questo punto dovrebbe iniziare a lampeggiare l'applicazione del Notepadd++ nella barra di sistema, a segnalare che il debug dello script è stato avviato.

5)Watchs
Clikare su watchs ->tasto dx mouse -> add watch -> inserire nome variabile

problemi di concorrenza

2011-02-26T14:24:00.000-08:00

Strumenti e tecniche per identificare i problemi di concorrenza

Rahul V. Patil e Boby George

In questo articolo verranno discussi i seguenti argomenti:

Problemi nel test della concorrenza
Bug elusivi e loro dipendenze
Nuovi strumenti per individuare gli ostacoli
Procedure consigliate per progettare i test

In questo articolo verranno utilizzate le seguenti tecnologie:
Analisi dinamica, analisi statica e controllo del modello

Sommario

Condizioni di competizione, deadlock e altro
Problemi di riordino della memoria
Strategie di test
Strumenti di test della concorrenza
Test delle prestazioni
Test di stress
Conclusioni

Per soddisfare l'eterna esigenza di aumentare la potenza di calcolo, il settore dell'hardware si sta costantemente muovendo verso sistemi di processori multicore. Al contrario del miglioramento delle prestazioni ottenuto grazie a processori più veloci con velocità di clock più elevate, il miglioramento delle prestazioni in sistemi multicore può essere ottenuto solo scrivendo programmi paralleli efficienti.

Da molto tempo nel settore del software esistono forme di parallelismo. Tuttavia, per creare applicazioni software tradizionali che utilizzino la piena potenza dell'hardware parallelo, è necessario modificare in modo sostanziale le pratiche pensate per le applicazioni sequenziali.

Il test delle applicazioni parallele non è semplice. Ad esempio, è difficile rilevare bug di concorrenza a causa del comportamento non deterministico mostrato dalle applicazioni parallele. Anche se si riesce a rilevare questi bug, è difficile riprodurli in modo coerente. Inoltre, dopo aver corretto un difetto, è difficile essere certi che quel difetto è stato veramente risolto e non semplicemente mascherato. La parallelizzazione può anche comportare nuovi colli di bottiglia delle prestazioni che devono essere identificati.

In questo articolo, esaminerò le tecniche di test per i programmi paralleli e presenterò sei utili strumenti che possono essere usati per individuare difetti potenzialmente gravi. Inizierò definendo le seguenti categorie di bug di concorrenza: condizioni di competizione, esclusioni reciproche errate e riordino della memoria.

Condizioni di competizione, deadlock e altro

Una condizione di competizione si verifica quando due o più thread di esecuzione di un programma multithread tentano di accedere agli stessi dati condivisi e almeno uno degli accessi è in scrittura. Condizioni di competizione dannose comportano imprevedibilità e sono spesso difficile da rilevare. Le conseguenze di una condizione di competizione possono diventare visibili solo molto tempo dopo o in una parte completamente diversa del programma. Sono anche difficilissime da riprodurre. È possibile evitare le competizioni usando tecniche di sincronizzazione per mettere correttamente in sequenza le operazioni tra i thread.

Identificazione dei dati di test e reporting delle metriche

Nel caso delle applicazioni parallele, i dati di test vengono definiti identificando gli aspetti di scalabilità dello scenario. La scalabilità mostrata dall'applicazione dipende in realtà dalla capacità di parallelizzazione dell'algoritmo usato. Determinati algoritmi possono produrre uno speedup superlineare per certi campi problematici (ad esempio una ricerca in una distribuzione non uniforme). Altri algoritmi non possono produrre speedup paralleli a causa della limitata capacità di parallelizzazione, di conseguenza la velocità di runtime totale aumenta in misura non proporzionale al numero di CPU. Altri algoritmi ancora, ad esempio quelli di ordinamento, non scalano in modo lineare attraverso la dimensione del set di dati. È evidente che è importante capire come scalano le prestazioni dell'applicazione con le categorie seguenti:

Numero di thread o core CPU - L'utente in genere si aspetta che l'applicazione parallela scalerà in modo lineare man mano che aumenta il numero di CPU o thread.

Dimensione del set di dati - L'utente in genere si aspetta che le prestazioni dell'applicazione parallela non debbano diminuire all'aumentare della dimensione del set di dati di input.

Carico di lavoro dell'esecuzione - Con il procedere dell'esecuzione, la quantità di lavoro svolto dal thread può non rimanere costante. Può aumentare o diminuire, variare in modo casuale o essere distribuita normalmente. Le variazioni del carico di lavoro nel corso dell'esecuzione possono influire sulle caratteristiche delle prestazioni dell'applicazione. I tipi di variazione del carico di lavoro nel corso dell'esecuzione sono: carico di lavoro costante, carico di lavoro in aumento, carico di lavoro in diminuzione, carico di lavoro casuale e carico di lavoro distribuito normalmente.

Il tempo di esecuzione è la metrica più comunemente usata per il reporting. Altre metriche di reporting includono lo speedup ottenuto rispetto all'applicazione sequenziale e lo speedup attraverso le categorie di scalabilità. È importante definire la metrica di reporting e la modalità di misurazione. Ecco alcune domande utili per iniziare: Quali valori devono essere riportati? Come verranno riportati? La strumentazione usata per la misurazione influisce sulle prestazioni? Inoltre, quando possibile, effettuare la misurazione in parti, in modo da capire le prestazioni delle sottoparti del sistema.

Talvolta le competizioni possono essere sicure e intenzionali. Ad esempio, può esserci un flag globale chiamato done, per il quale esiste solo un thread scrittore ma molti thread lettori. Il thread scrittore imposta il flag in modo da indicare a tutti i thread di terminare in modo sicuro. Tutti i thread lettori possono essere eseguiti in un loop utilizzando while (!done), leggendo ripetutamente il flag. Dopo che un thread ha rilevato l'impostazione del flag done, esce dal proprio loop while. In molti casi si tratta di una competizione favorevole. Come vedremo più avanti in questo articolo, sono disponibili degli strumenti per il rilevamento delle condizioni di competizione. Tuttavia tali strumenti potrebbero segnalare competizioni che in realtà sono favorevoli, riportando errori conosciuti come falsi positivi.

Un deadlock si verifica quando due o più thread sono in attesa l'uno dell'altro, dando vita a un ciclo e impedendo a tutti loro di fare ulteriori progressi. I deadlock possono essere introdotti dal programmatore nel tentativo di evitare condizioni di competizione. Ad esempio, l'uso errato di primitivi di sincronizzazione, come l'acquisizione di blocchi in un ordine sbagliato, può comportare l'attesa reciproca di due o più thread. I deadlock possono verificarsi anche nei casi in cui non si usano costrutti di blocco; qualsiasi tipo di attesa circolare può risolversi in un deadlock.

Esaminiamo l'esempio seguente di una potenziale situazione di deadlock. Il thread 1 effettua quanto segue:

Acquire Lock A;
Acquire Lock B; 
Release Lock B; 
Release Lock A;
Thread 2 proceeds like so:
Acquire Lock B;
Acquire Lock A; // if thread 1 has already acquired lock 
                // A and waiting to acquire lock B, then 
                // this is a deadlock
Release Lock A;
Release Lock B;

Per starvation, o inedia, si intende un ritardo indefinito o un blocco permanente di uno o più thread eseguibili in un'applicazione multithread. I thread la cui esecuzione non è pianificata, sebbene non stiano bloccando o aspettando nulla, vengono detti in condizione di starvation. La condizione di starvation è generalmente il risultato di regole e criteri di pianificazione. Ad esempio, se si pianifica un thread ad alta priorità, non bloccante e continuamente in esecuzione insieme a un thread a bassa priorità, in una CPU a singolo core, il thread a bassa priorità non avrà mai la possibilità di essere eseguito. Per evitare tali condizioni, l'utilità di pianificazione di Windows® interviene frequentemente per ridurre la starvation, aumentando occasionalmente le priorità dei thread in starvation.

I livelock, attese indefinite, si verificano quando i thread sono pianificati ma non stanno facendo progressi perché stanno reagendo continuamente al cambiamento di stato di ognuno di loro. Il modo migliore per descrivere questa condizione è con questo esempio: due persone che si avvicinano in un corridoio stretto e ognuna si fa da parte per far passare l'altra, bloccandosi reciprocamente la strada. Questo farsi da parte impedisce l'avanzamento e comporta un livelock. Un elevato utilizzo di CPU senza alcun sintomo di un lavoro realmente in corso è il classico segnale di un livelock. I livelock sono difficilissimi da rilevare e diagnosticare.

Problemi di riordino della memoria

Quando il compilatore ottimizza il codice, può decidere di riordinare parti di codice per migliorare le prestazioni. Tuttavia può generare un comportamento imprevisto nei thread che tengono sotto controllo le modifiche allo stato globale. Ad esempio, supponiamo di avere due thread di esecuzione: il thread 1 e il thread 2. Supponiamo anche di avere due variabili globali, x e y, inizializzate entrambe su 0. Il thread 1 esegue queste righe:

x=10;
y=5;

Il thread 2 esegue queste righe:

if (y == 5)
{
  Assert(x != 10);
}

In questo caso il compilatore di ottimizzazione potrebbe osservare che, alla fine, a y verrà riassegnato comunque il valore 5 e potrebbe riordinare il codice in modo che a y venga assegnato 5 prima che a x venga assegnato 10; dal punto di vista del singolo thread che esegue queste due assegnazioni, l'ordinamento è ininfluente. Pertanto c'è una possibilità che l'asserzione del thread 2 non valga più, dato che x potrebbe non essere uguale a 10.

Se necessario, è possibile evitare il riordino della memoria da parte del compilatore usando variabili volatili ed elementi intrinseci del compilatore. È importante accennare anche al fatto che, con comuni flag di ottimizzazione attivati, il thread 2 potrebbe non vedere mai un aggiornamento alle variabili y o x. In questo caso sarà necessario usare variabili volatili.

Il riordino da parte del compilatore non è l'unica complicazione. Con le ottimizzazioni dell'accesso alla memoria, come il caching e il recupero avanzato per mezzo di esecuzioni speculative, può succedere che le operazioni di memoria eseguite da un thread in una CPU vengano percepite come eseguite in un ordine diverso da un altro thread su un'altra CPU. Questo tipo di percezione di riordino della memoria può verificarsi solo in un sistema con più CPU o CPU multicore.

Per chiarire supponiamo di avere due thread di esecuzione: il thread 1 e il thread 2. Quindi supponiamo che m e n siano variabili globali inizializzate entrambe su 0 e che a, b, c, d siano variabili locali. Il thread 1 (nel processore 1) ha queste istruzioni:

m = 5;     // A1
int a = m; // A2
int b = n; // A3

Il thread 2 (nel processore 2) ha queste istruzioni:

n = 5;     //A4
int c = n; //A5
int d = m; //A6

Per logica, in un ambito di memoria coerente e sequenziale, dopo l'esecuzione di tutte queste istruzioni, non può mai verificarsi b == d == 0. Tuttavia, con il riordino della memoria hardware, le scritture nella memoria condivisa (A1 e A4) possono essere indirizzate al buffer di archiviazione, di conseguenza diversi processori possono osservare le scritture in modo diverso.

Strategie di test

Il test di un'applicazione concorrente implica le verifica della correttezza, dell'affidabilità, delle prestazioni e della scalabilità. La correttezza dell'applicazione viene determinata usando tecniche quali l'analisi statica, l'analisi dinamica e il controllo del modello. Le prestazioni e l'affidabilità vengono controllate per mezzo dello studio degli overhead introdotti dal parallelismo e il test di stress. La scalabilità viene controllata analizzando le prestazioni dell'applicazione in sistemi di diversa grandezza.

Le tecniche di analisi statica analizzano il codice senza eseguire effettivamente il programma. Di solito, l'analisi statica viene eseguita esaminando i metadati di un'applicazione compilata o il codice sorgente con annotazioni. L'analisi include in genere un'ispezione formale per garantire che l'intento e i presupposti del programmatore impediscano un comportamento errato. I due strumenti di analisi statica per le applicazioni native più famosi sono Prefix e Prefast mentre FxCop è molto usato per il codice gestito.

L'analisi statica presenta vantaggi e svantaggi. Tra i vantaggi vi sono la copertura completa e dettagliata, la garanzia dell'affidabilità del progetto del codice e la precisione dei report sugli errori che facilitano l'individuazione e la correzione dei bug. Tuttavia, per gestire i bug di concorrenza, l'analisi statica richiede un grosso impegno di annotazione. Inoltre, queste annotazioni devono essere corrette da sole. Gli strumenti che usano l'analisi statica tendono anche a generare molti falsi positivi e quindi richiedono un notevole impegno per ridurli al minimo.

Nell'analisi dinamica i bug vengono rilevati dall'esame dei footprint di esecuzione. Esistono due tipi di analisi dinamica: online e offline. Gli strumenti che usano l'analisi dinamica online analizzano un programma mentre è in esecuzione; gli strumenti che usano l'analisi dinamica offline registrano le tracce e le analizzano in un secondo momento per rilevare i bug. L'analisi dinamica è uno strumento utile in quanto richiede un lavoro minimo, se non nessuno, allo sviluppatore al momento della programmazione, genera un numero minore di falsi positivi e facilita la soluzione dei problemi più ovvi. Poiché i bug vengono rilevati solo nel percorso di esecuzione, i percorsi attraversati più spesso generano la prima serie di bug. In questo modo è più facile migliorare l'affidabilità.

Ma ci sono anche degli svantaggi. I bug possono essere rilevati solo nel percorso di esecuzione ed è necessario affidarsi ai test case per avere una buona copertura del codice. Infatti alcuni strumenti possono cogliere una competizione solo se questa si verifica in quell'esecuzione. Pertanto, se lo strumento non riporta nessun bug, non si può essere certi che non ve ne siano. Molti strumenti di analisi dinamica si fondano su una sorta di strumentazione che può modificare il comportamento del runtime, il che è un altro svantaggio. A causa della complessità, le prestazioni di questi strumenti tendono a essere molto scarse.

L'ultimo metodo è il controllo del modello: il metodo per verificare la correttezza di un sistema concorrente con stato finito. Consente un ragionamento deduttivo formale. Uno strumento di controllo del modello cerca di simulare condizioni di competizione e deadlock. Utilizzando il controllo del modello, è possibile dimostrare formalmente l'assenza di competizioni e deadlock. Questo metodo garantisce una maggiore affidabilità del progetto e dell'architettura e richiede un numero minimo di driver esterni.

Come altri metodi di test, il controllo del modello presenta alcuni svantaggi. Spesso è molto difficile estrarre automaticamente il modello dal codice (esistono rari casi con uso limitato). Anche l'esecuzione manuale dell'estrazione del modello è piuttosto noiosa. Inoltre richiede una verifica estesa a causa del problema conosciuto come "state space explosion", una condizione in cui il numero potenziale di stati possibili è troppo grande da analizzare. Questa condizione può essere controllata in una certa misura applicando tecniche di riduzione che usano una complicata euristica. Anche l'euristica presenta dei limiti, come il non saper rilevare i bug in applicazioni a esecuzione prolungata.

Infine il controllo del modello richiede una rigorosa pianificazione del progetto e dell'implementazione. Il controllo del modello può dimostrare che il progetto è privo di errori ma non l'implementazione. In pratica, il controllo del modello è utile per piccole e importanti sezioni di un prodotto. Altre tecniche ibride includono la combinazione di analisi dinamica e controllo del modello. Un esempio è dato da CHESS che verrà descritto in breve.

Algoritmi di rilevamento delle competizioni

L'algoritmo "lockset", usato in entrambi gli strumenti di analisi statica e dinamica, segnala una competizione potenziale quando due o più thread accedono alla memoria condivisa senza gestire un blocco comune. L'algoritmo indica in sostanza che, per ogni variabile v della memoria condivisa, ogni thread gestirà una serie non vuota di blocchi C(v) durante l'accesso alla variabile. Inizialmente C(v) è l'elenco di tutti i blocchi. Ogni thread gestisce anche due serie di blocchi: locks(t) indica tutti i blocchi gestiti e writeLocks(t) indica tutti i blocchi in scrittura gestiti. Ecco come procede l'algoritmo:

Per ogni variabile v della memoria condivisa gestisce una serie C(v) di blocchi. Inizialmente C(v) è l'elenco di tutti i blocchi.
Ogni thread gestisce anche due serie di blocchi: locks(t) indica tutti i blocchi gestiti e writeLocks(t) indica tutti i blocchi in scrittura gestiti.
In ogni lettura di v da parte del thread t:
1. Set C(v) = C(v) intersection locks(t).
2. If C(v) == NULL set, then raise an error.
In ogni scrittura di v da parte del thread t:
1. Set C(v) = C(v) intersection writeLocks(t).
2. If C(v) ==NULL set, then raise an error.

Sostanzialmente, man mano che l'applicazione procede, la serie C(v) di ogni variabile inizia a restringersi. Viene generato un errore se C(v) diventa nullo (ad esempio, se le intersezioni dei lockset dei thread sono nulle al momento di accedere alla memoria condivisa).

Purtroppo non tutte le competizioni segnalate da un algoritmo "lockset" sono competizioni reali. È possibile scrivere codice libero da competizioni senza usare blocchi applicando trucchi intelligenti di programmazione o usando primitivi di sincronizzazione come la segnalazione. Ciò complica notevolmente l'individuazione dei veri bug. Le annotazioni e determinate soppressioni possono aiutare ad alleviare questo problema.

Un altro algoritmo per rilevare le competizioni è "happens-before" che si basa sull'ordinamento parziale degli eventi in sistemi distribuiti. Ecco una panoramica dell'algoritmo che calcola l'ordine parziale per stabilire quali eventi sono successi prima di un altro evento (in questo contesto, per eventi si intendono tutte le istruzioni, comprese quelle di lettura, scrittura e blocchi):

All'interno di ogni singolo thread, gli eventi vengono ordinati in base al loro verificarsi.
Tra i thread, gli eventi vengono ordinati in base alle proprietà dei primitivi di sincronizzazione. Ad esempio, se lock(a) viene acquisito da due thread, allora si è verificato uno sblocco da parte di un thread prima del blocco di un altro thread.
Se due o più thread accedono a una variabile condivisa e gli accessi non sono ordinati in modo deterministico dalla relazione "happens-before", allora si è verificata una competizione.

L'algoritmo è illustrato nella Figura A.

Lo sblocco del thread 1 si è verificato prima del blocco del thread 2. Pertanto, l'accesso alla variabile condivisa non può mai verificarsi allo stesso tempo e non esiste competizione. Uno dei principali svantaggi dell'algoritmo deriva dal fatto che il monitoraggio di tali relazioni può essere molto dispendioso.

Il problema più grande è che la capacità di questo algoritmo di rilevare le competizioni dipende completamente dall'ordine di pianificazione. L'ordine parziale viene creato solo per questa specifica istanza della pianificazione e può non cogliere i bug per lo stesso test in un altro giorno. La Figura B non riporta nessuna competizione mentre un ordine di esecuzione nella Figura C riporta le competizioni. È stato appurato che molte competizioni si sono verificate solo diversi anni dopo il rilascio di un prodotto. Pertanto questo rilevamento non garantisce di avere un'assoluta copertura.

D'altro canto, l'algoritmo "happens-before" genera solo pochi falsi positivi. La maggior parte dei bug sono reali. Tuttavia "happens-before" induce a molti falsi negativi, non rilevando diversi errori, ed è molto difficile da implementare in modo efficiente.

L'algoritmo "lockset", invece, è molto efficiente e può rilevare più errori, sebbene tenda a generare troppi falsi positivi. Si sono fatti molti sforzi per unificare questi algoritmi e superare gli svantaggi di entrambi gli approcci. Nota: questi algoritmi di rilevamento delle competizioni si sono evoluti nel corso di diversi anni; informazioni su di essi sono reperibili nei portali ACM /IEEE.

Figura A Algoritmo Happens-Before (Fare clic sull'immagine per ingrandire la vista)

Figura B Non verranno rilevate competizioni (Fare clic sull'immagine per ingrandire la vista)

Figura C Verranno rilevate competizioni (Fare clic sull'immagine per ingrandire la vista)

Strumenti di test della concorrenza

In commercio sono disponibili diversi strumenti di test della concorrenza, utili per gestire potenziali deadlock, livelock, blocchi e tutti gli altri problemi che possono presentarsi durante l'esecuzione di transazioni parallele. Ogni strumento che esamineremo è utile in una particolare area.

CHESS. Creato da Microsoft Research, CHESS è un'originale combinazione di controllo del modello e di analisi dinamica (vedere go.microsoft.com/fwlink/?LinkId=116523, in inglese). Rileva gli errori di concorrenza esplorando sistematicamente le pianificazioni dei thread e l'interfoliazione. È in grado di trovare condizioni di competizione, deadlock, blocchi, livelock e problemi di danneggiamento dei dati. Per aiutare il debugging, fornisce anche un'esecuzione completamente ripetibile. Come molti controlli del modello, l'esplorazione sistematica fornisce una copertura totale.

In quanto strumento di analisi dinamica, CHESS esegue ripetutamente un normale unit test a determinati intervalli, in base a una speciale pianificazione. A ogni ripetizione, sceglie un ordine di pianificazione diverso. In quanto strumento di controllo del modello, controlla la speciale utilità di pianificazione che è in grado di creare specifiche interfoliazioni di thread. Per controllare il problema "state space explosion", CHESS applica la riduzione dell'ordine parziale e un'originale limitazione del contesto di iterazione.

Nella limitazione del contesto di iterazione, invece di limitare lo "state space explosion" in base alla profondità, CHESS limita il numero di passaggi di thread in una determinata esecuzione. Il thread può eseguire qualsiasi numero di fasi tra un passaggio e l'altro, lasciando la profondità di esecuzione illimitata (un grande successo sul tradizionale controllo del modello). Ciò si basa sulla prova empirica che un numero limitato di passaggi di thread sistematici è sufficiente a mostrare la maggior parte dei bug di concorrenza.

CHESS può rilevare deadlock e competizioni, usando l'algoritmo "Goldilocks lockset" spiegato in go.microsoft.com/fwlink/?LinkId=116877 (in inglese) ma si basa sulle asserzioni del programmatore per la verifica di altri stati. Inoltre prevede la chiusura di tutti i programmi e garantisce l'equità di progresso per tutti i thread. Pertanto, se il programma entra in uno stato di loop continuo, CHESS segnala un livelock.

Dal punto di vista del test, è preferibile iniziare eseguendo CHESS con un limite del contesto di iterazione di 2. Una volta che non ci sono più bug da trovare, aumentare il limite a 3 e così via. È stato dimostrato in modo empirico che la maggior parte dei bug viene rilevata con un limite di 2 e 3. Pertanto si tratta di un modo molto efficiente per eliminare subito i bug.

Per quanto riguarda la strumentazione, CHESS devia le chiamate di sincronizzazione dell'API Win32® da controllare e introduce intenzionalmente il non determinismo. Inoltre richiede che il codice dello sviluppatore includa molte asserzioni per garantire la coerenza degli stati (ciò che ogni buon codice dovrebbe fare comunque). Tuttavia, come la maggior parte degli strumenti di analisi dinamica, richiede una valida suite di test per garantire un'ampia copertura. CHESS costituisce un vantaggio per tutti quegli sviluppatori e collaudatori che devono affidarsi esclusivamente allo stress per eseguire un test interfoliato migliore. Esegue normali unit test e simula metodicamente interessanti interfoliazioni.

Intel Thread Checker. È uno strumento di analisi dinamica per trovare i deadlock (compresi quelli potenziali), gli stalli, le competizioni di dati e gli usi impropri delle API di sincronizzazione native Windows (vedere go.microsoft.com/fwlink/?LinkId=115727, in inglese). Thread Checker deve dotare sia il codice sorgente sia il codice binario compilato degli strumenti necessari a rendere osservabili ogni riferimento alla memoria e ogni primitivo di sincronizzazione Win32 standard. In fase di runtime, il codice binario così attrezzato fornisce informazioni sufficienti affinché l'utilità di analisi costruisca un ordine parziale di esecuzione. Lo strumento quindi esegue un'analisi "happens-before" dell'ordine parziale. Fare riferimento all'intestazione laterale "Algoritmi di rilevamento delle competizioni" per ulteriori informazioni sull'analisi "happens-before".

Per motivi di prestazioni e scalabilità, invece di ricordare tutti gli accessi a una variabile condivisa, lo strumento ricorda solo gli accessi recenti. Ciò aiuta a migliorare l'efficienza dello strumento durante l'analisi di applicazioni a esecuzione prolungata, tuttavia lo strumento non rileverà alcuni bug, un classico compromesso: forse è più importante trovare molti bug in applicazioni a esecuzione prolungata che trovare tutti i bug in un'applicazione di durata molto breve.

L'altro grande svantaggio dello strumento è che non può rendere conto della sincronizzazione tramite operazioni interlock, come quelle usate in blocchi rotanti personalizzati. Tuttavia, per le applicazioni che usano solo primitivi di sincronizzazione standard, si tratta di uno degli strumenti di test meglio supportati a disposizione per le applicazioni native di test della concorrenza.

RacerX. Questo strumento di analisi statica sensibile al flusso è usato per rilevare competizioni e deadlock. Non richiede noiose annotazioni nell'intero codice sorgente. Infatti, l'unico requisito di annotazione è quello per cui gli utenti devono fornire una tabella che specifica le API usate per acquisire e rilasciare i blocchi. È possibile specificare anche gli attributi dei primitivi di blocco, come spinning, blocking e re-entrancy. Questa tabella in genere sarà molto piccola (30 voci al massimo). In questo modo si riduce enormemente l'onere dell'annotazione del codice sorgente per grandi sistemi.

Nella prima fase, RacerX esegue l'iterazione in ogni file del codice sorgente e crea un CFG (Control Flow Graph). Il CFG contiene informazioni relative alle chiamate alle funzioni, alla memoria condivisa, all'uso di puntatori e ad altri dati. Mentre crea il CFG, fa anche riferimento alla tabella dei primitivi di sincronizzazione ed effettua chiamate a queste API.

Una volta creato il CFG, subentra la fase di analisi che include l'esecuzione dello strumento di controllo delle competizioni e dei deadlock. Attraversare il CFG può essere un'operazione lunga ma è possibile usare tecniche appropriate di riduzione e caching per ridurre al minimo l'impatto. Man mano che si attraversa il flusso del contesto, viene usato l'algoritmo "lockset" per rilevare competizioni potenziali (fare riferimento all'intestazione laterale "Algoritmi di rilevamento delle competizioni" per dettagli sull'algoritmo). Per quanto riguarda l'analisi dei deadlock, lo strumento calcola i cicli di blocco ogni volta che viene preso un blocco.

La fase finale riguarda la postelaborazione di tutti gli errori segnalati per stabilire la priorità di importanza e la pericolosità dell'errore. Come per l'analisi statica, gli autori hanno dedicato molto tempo al tentativo di ridurre i falsi positivi e presentare i bug con una notevole sicurezza. I risultati di questo strumento sono stati impressionanti; sembra molto pratico dal punto di vista dell'ingegneria di test.

Chord. È uno strumento di analisi statica per Java, sensibile al contesto e insensibile al flusso. Essendo insensibile al flusso, è molto più scalabile di altri strumenti statici ma a scapito della precisione. Prende anche in considerazione i primitivi di sincronizzazione disponibili in Java. L'algoritmo usato è molto complesso e richiederebbe l'introduzione di molti concetti. Per ulteriori informazioni su Chord, vedere go.microsoft.com/fwlink/?LinkId=116526 (in inglese).

KISS. Sviluppato da Microsoft Research, questo strumento di controllo del modello è valido per i programmi C concorrenti. Poiché in un sistema concorrente si verifica subito un problema "state space explosion", KISS trasforma un programma C concorrente in un programma sequenziale che simula l'esecuzione dell'interfoliazione. Per eseguire l'analisi, viene quindi usato uno strumento di controllo del modello sequenziale.

L'applicazione viene dotata di istruzioni che convertono il programma concorrente in un programma sequenziale e KISS si occupa di controllare il non determinismo. Il passaggio al contesto di non determinismo è limitato da principi simili a quelli descritti sopra per CHESS. Si presuppone che il programmatore introduca asserzioni che convalidano i presupposti di concorrenza. Lo strumento non riporta falsi positivi. Lo strumento è un prototipo di ricerca ed è stato usato dal team dei driver di Windows, che usa principalmente il codice C (vedere go.microsoft.com/fwlink/?LinkId=115723, in inglese).

Zing. Questo strumento è un puro strumento di controllo del modello, pensato per la verifica del progetto di programmi concorrenti. Zing ha un proprio linguaggio personalizzato che è usato per descrivere transizione e stati complessi ed è perfettamente in grado di modellare macchine a stati. Come gli altri strumenti di controllo del modello, Zing fornisce un metodo completo per verificare i progetti; aiuta a garantire la qualità del progetto in quanto è possibile verificare i presupposti e dimostrare formalmente la presenza o l'assenza di determinate condizioni. Affronta anche il problema "state space explosion" con innovative tecniche di riduzione.

Il modello usato da Zing (per controllare la correttezza del programma) deve essere creato manualmente o da convertitori. Mentre è possibile scrivere alcuni convertitori specifici, dobbiamo ancora trovare convertitori completi e funzionanti per le applicazioni native o CLR. Senza convertitori, crediamo che Zing non possa essere usato in grandi progetti software tranne che per la verifica della correttezza di sottosezioni critiche del progetto (vedere go.microsoft.com/fwlink/?LinkId=115725, in inglese).

Test delle prestazioni

Il test delle prestazioni è parte integrante ed essenziale del processo di test della concorrenza. In fondo, uno dei motivi principali per sviluppare applicazioni parallele è offrire prestazioni migliori di quelle delle applicazioni sequenziali. Come postulato nella legge di Amdahl e nella legge di Gustafson, il miglioramento delle prestazioni ottenuto per mezzo di un'applicazione parallela è in gran parte influenzato dalla capacità di parallelizzazione dell'algoritmo, dalla quantità di parti sequenziali nel programma, dall'overhead di parallelizzazione e dalle caratteristiche di dati/carico di lavoro. L'esecuzione di test delle prestazioni consente ai soggetti interessati di capire e analizzare le caratteristiche delle prestazioni delle applicazioni parallele.

La metodologia generale per eseguire test delle prestazioni delle applicazioni parallele resta la stessa del test delle prestazioni delle applicazioni sequenziali. La sezione seguente descrive come alcune fasi essenziali del test delle prestazioni debbano essere adattate alle applicazioni concorrenti. Per una comprensione dei fattori di misurazione più utili, vedere l'intestazione laterale "Identificazione dei dati di test e reporting delle metriche".

La fase più importante del test delle prestazioni consiste nel definire gli obiettivi o lo scopo del test. Per le applicazioni parallele, tra gli obiettivi validi del test vi sono la comprensione della capacità di parallelizzazione/scalabilità dell'algoritmo usato, la comprensione delle caratteristiche delle prestazioni di varie alternative di progettazione, la scoperta degli overhead di comunicazione e sincronizzazione e la convalida che i requisiti delle prestazioni sono stati soddisfatti.

È opportuno notare che gli obiettivi e lo scopo del test delle prestazioni possono variare anche in base a chi conduce il test. Ad esempio, i clienti che implementano un'applicazione parallela potrebbero eseguire test delle prestazioni per assicurarsi che siano soddisfatte le esigenze dell'azienda, mentre il team di sviluppo potrebbe essere interessato a eseguire un test completo delle prestazioni per identificare i colli di bottiglia e migliorare la capacità di parallelizzazione del programma. Inoltre, gli obiettivi del test possono variare nel ciclo di sviluppo del software. Durante la fase di progettazione e implementazione, l'obiettivo del test potrebbe essere comprendere e migliorare le caratteristiche delle prestazioni dell'applicazione, mentre durante le fasi di test e rilascio (fasi di stabilizzazione) l'obiettivo potrebbe essere assicurarsi che le prestazioni non peggiorino durante i build.

La definizione degli scenari del test e la definizione degli obiettivi sono un'altra fase importante nel processo di test delle prestazioni. I team di sviluppo interessati alla comprensione delle caratteristiche delle prestazioni di un'applicazione parallela dovrebbero definire tre tipi di scenari di test: test in scenari dei clienti, test dell'indicatore KPI (Key Performance Indicator) e test dei MBM (Micro BenchMark).

La relazione tra questi tipi diversi di test delle prestazioni può essere considerata equivalente a quella che esiste tra i test di sistema, i test di integrazione e gli unit test. In altre parole, i test di uno scenario dei clienti generano una serie di test KPI e un test KPI genera una serie di test MBM. La comprensione della relazione tra questi tipi diversi di test consente agli sviluppatori di comprendere le relazioni delle prestazioni tra le varie sottoparti di un'applicazione parallela. Acquisire questa comprensione permette anche di definire una migliore priorità dei bug delle prestazioni e, ancora più importante, consente al team di sviluppo di rispondere alle lamentele dei clienti sulle prestazioni con suggerimenti orientati ai risultati.

L'impostazione di obiettivi di prestazioni per qualsiasi applicazione non banale è un'operazione difficile, figuriamoci per le applicazioni parallele. Un approccio consiste nel ricavare l'obiettivo da metriche di triangolazione ottenute da una determinata metrica delle prestazioni a livello teoretico o di algoritmo per ogni componente e sottocomponente dell'applicazione, dall'analisi comparativa (tra i candidati al confronto ci sono applicazioni simili rivali) e dalla definizione del profilo dell'implementazione/applicazione eventualmente esistente.

Ogni scenario di test dovrebbe definire una serie di criteri di accettazione (una serie di valori che convalidano i risultati del test). Nel caso di scenari di test paralleli, è possibile usare le variabili seguenti come criteri di accettazione.

Varianza nei risultati del test. Indica un'applicazione instabile. La varianza nei risultati del test può essere compresa calcolando la deviazione standard dei risultati.

Utilizzo della CPU. Un basso utilizzo della CPU potrebbe indicare bug di concorrenza, come deadlock e overhead di sincronizzazione. Al contrario, un elevato utilizzo della CPU non è necessariamente un indicatore positivo in quanto i livelock si verificano proprio con un elevato utilizzo della CPU.

Garbage Collection. Per le applicazioni gestite, troppe operazioni di gestione della memoria possono ostacolare l'esecuzione effettiva del lavoro e potrebbero indicare errori di progettazione o implementazione.

Tempo totale di esecuzione del thread. Consente di calcolare all'incirca il tempo totale di esecuzione se il programma doveva essere eseguito sequenzialmente. Confrontando il tempo totale di esecuzione del thread con il tempo trascorso dell'implementazione sequenziale dello stesso programma algoritmo, è possibile comprendere gli overhead di parallelizzazione (e vedere se il test è valido).

Utilizzo totale della memoria. La misura dell'utilizzo totale della memoria è preziosa per capire il profilo della memoria dell'applicazione. Per le applicazioni gestite, il garbage collector ricopre un ruolo significativo nel modificare l'utilizzo totale della memoria dell'applicazione e dovrebbe essere preso in considerazione durante la valutazione dell'utilizzo della memoria.

Prima di iniziare il test delle prestazioni, ci sono tre fasi importanti da seguire per garantire risultati più pertinenti. Innanzitutto, ridurre al minimo la varianza nell'ambiente di test (la varianza può essere introdotta sia dall'applicazione che dall'ambiente di test). È possibile ridurre le varianze nell'ambiente di test interrompendo i servizi e le applicazioni non necessarie e riducendo le interferenze di rete. La varianza causata dall'applicazione può essere ridotta eseguendo iterazioni warm-up e raccogliendo misure da più iterazioni del test.

In secondo luogo, per le applicazioni gestite, l'esecuzione inopportuna del garbage collector può invalidare i risultati del test. Di conseguenza, è opportuno ridurre al minimo le possibilità che il garbage collector venga richiamato durante le misurazioni delle prestazioni forzandone il richiamo prima o dopo la raccolta della misura e/o cambiando GCLatencyMode in LowLatency (ciò è vero solo in Microsoft® .NET Framework 3.5).

In terzo luogo, eseguire il warm-up prima della raccolta delle metriche. Il warm-up, ottenuto eseguendo il test una volta prima della raccolta della misurazione, riduce il costo di operazioni come l'inizializzazione delle variabili, il costo JITing (nelle applicazioni gestite) ed evita la latenza per la cache iniziale. Notare che, a seconda degli scenari delle prestazioni, potrebbe essere importante misurare anche l'avvio a freddo delle prestazioni (per ulteriori informazioni sul miglioramento delle prestazioni all'avvio di un'applicazione, vedere msdn2.microsoft.com/magazine/cc337892.aspx).

Letture consigliate sul test della concorrenza (in inglese)

Using Synchronization

go.microsoft.com/fwlink/?LinkId=115730

Bugslayer: Wait Chain Traversal

msdn2.microsoft.com/magazine/cc163395

No More Hangs: Advanced Techniques to Avoid and Detect Deadlocks in .NET Apps

msdn2.microsoft.com/magazine/cc163618

sviluppo di un business online

2011-02-11T10:36:00.001-08:00

Articoli su sviluppo di un business online.
Ecco alcuni suggerimenti per iniziare:

Bookmarklet chicche: Gmail e Respelt

8 Dicembre 2010

Ho iniziato a usare le relativamente recenti, e ha scoperto che sono bookmarklets ottimo modo per aumentare la produttività. Per utilizzare il bookmarklet basta trascinare i link bookmarklet (come quelli di seguito) per la vostra barra dei segnalibri del browser.

Lascia un commento

Con il potere viene responsabilità

19 novembre 2010

Questa è l'immagine di un sostegno Gmail labs forum di questa mattina quando mi sono recato di lasciare il feedback. Ho subito perso le motivazioni. Quanto costa a Google di assumere 3-4 persone che lavoreranno a tempo pieno come moderatori dei propri forum? Btw la caratteristica che stavo per suggerire è stato quando si preme il pulsante segnala come spam di Gmail (che io mai così spesso fanno) , il sistema automaticamente invia un bel messaggio personalizzato per lo spammer.

3 Commenti

Respelt.com - Controllo ortografico automatico il tuo blog

17 novembre 2010

Felice di annunciare che abbiamo appena lanciato una nuova applicazione chiamata Respelt.Respelt controllo ortografico consente di eseguire il controllo ortografico qualsiasi testo o una pagina, ma anche possibile controllare i tuoi post automaticamente. E 'molto semplice e facile da usare. Basta registrarsi per un account gratuito, e aggiungere i feed RSS del vostro blog. Otterrete i report via email, se si verificano eventuali errori di ortografia. Ecco il video.Sign introduttivo su al Respelt.com

seo doctor

2011-02-11T10:35:00.001-08:00

ManageWP diventa più potente

8 febbraio 2011

ManageWP.com sta attualmente gestendo più di 6.000 blog e noi siamo noi siamo felici di annunciare un altro importante aggiornamento di oggi. Cosa c'è di nuovo? Caricamento statistiche blog ora è asincrono, che migliora drasticamente il tempo di caricamento cruscotto in particolare per quelli di voi che gestiscono 100 blog. L'interfaccia è stata inoltre rinnovato per una migliore esperienza utente.

WordPress

2 Commenti

Non mi scaricare e utilizzare il plugin!

7 Febbraio 2011

Ricevo questo tipo di osservazioni più e più volte. Non mi scaricare e utilizzare il plugin se non si "(fai come ti dico)" O è un ottimo plugin, ma purtroppo dovrò disinstallarlo a meno di te "(aggiungere qualche ricatto virgolette)" E 'una situazione del genere buffo in modo che mi ha spinto a fare questa immagine:) Su una nota più seria, ho trovato questo articolo grande chiamata "Hey WordPress, smettere di trattare gli sviluppatori di plugin per uso professionale, come cittadini di seconda classe", che rispecchia un altro problema su un fronte diverso.

WordPress

9 Commenti

Plugin Wordpress Top Recensione

31 Gennaio 2011

Ho ricevuto il libro "Top Wordpress Plugin" di Brandon Corbin da Packt Publishing, la società stessa che ha pubblicato il mio libro paio di anni fa (Tornerò a quella successiva). La revisione può sembrare po 'troppo critico e mi scuso con Brandon up-front come so che tipo di sforzo che doveva mettere in ordine per ottenere questo libro. Il Buono Il libro spiega come cercare, caricare e installare plugin in dettaglio, che è qualcosa di neofiti apprezzeranno.

WordPress

4 Commenti

Come per la ricerca di Google con la ricerca personalizzata per disabili

29 gennaio 2011

parole chiave

2011-02-09T11:20:00.001-08:00

Oggi ti propongo le 100 poarole chiave più costose in Adwords,cioè le Keywords dove gli inserzionisti spendono una fortuna per far cliccare un singolo utente sul loro annuncio,quindi sicuramente un buon modo per scegliere un argomento di un articolo o addirittura il tema principale di un blog.

Certo,il tema di un blog dovrebbe sempre raffigurare la propria passione,le proprie competenze,la voglia di scrivere di un certo argomento,ma dare un’occhiata alle keywords (quindi a potenziali nicchie) proficue non è certo un male… :mrgreen:
Keyword Cost Per Click Clicks/Day Cost/Day
selling structured settlements $64.81 0.1 $0.00
cash for structured settlements $63.87 0.1 $0.00
auto insurance quotes florida $62.57 0.1 $0.00
california auto insurance quotes $57.34 0.1 $0.00
auto insurance quotes california $57.01 0.1 $0.00
student loan consolidation interest rate $56.86 0.1 $0.00
lendingtree .com $56.35 3.5 $197.22
consolidate loan refinance student $55.86 0.1 $0.00
audio conference calling $55.32 0.1 $0.00
arizona divorce attorneys $53.56 0.1 $0.00
dui attorney los angeles $52.75 0.5 $26.37
business conference calls $52.41 0.1 $0.00
personal injury attorneys chicago $51.59 0.1 $0.00
mesothelioma treatment options $51.31 0.1 $0.00
copper repiping $50.94 0.1 $0.00
conference calling services $49.65 1.0 $49.65
houston criminal lawyer $49.59 0.5 $24.79
criminal houston lawyer $49.59 0.5 $24.79
corporate conference calls $49.35 0.1 $0.00
sell annuity settlement $49.11 0.1 $0.00
student loan consolidation rates $48.80 0.1 $0.00
irs tax attorney $48.78 1.0 $48.78
california criminal defense lawyers $48.38 0.1 $0.00
universal life insurance quote $48.34 2.0 $96.68
san diego criminal lawyer $48.30 0.1 $0.00
irs help $48.27 4.5 $217.21
web based conferencing services $47.80 0.1 $0.00
american tax relief $47.37 0.5 $23.68
criminal defense attorney los angeles $47.34 0.1 $0.00
pacific coast pillows $47.24 1.0 $47.24
chicago personal injury lawyers $46.81 0.1 $0.00
sell annuity payments $46.73 0.1 $0.00
san diego criminal attorney $46.61 0.1 $0.00
los angeles criminal defense attorney $46.59 0.1 $0.00
data recovery seattle $46.59 0.1 $0.00
student loan consolidation rate $46.29 2.0 $92.58
college loan consolidation $46.29 2.5 $115.72
dui attorney san diego $46.04 0.1 $0.00
consolidate school loans $45.94 0.1 $0.00
federal criminal defense attorneys $45.86 0.1 $0.00
irs problem $45.68 1.5 $68.52
mesothelioma lawyers $45.48 2.0 $90.96
chicago injury lawyers $45.22 0.1 $0.00
federal criminal lawyer $45.18 0.5 $22.59
white water rafting maine $45.18 0.5 $22.59
maine white water rafting $45.18 0.5 $22.59
best home equity loans $45.14 1.5 $67.71
universal life quote $45.11 2.5 $112.77
consolidate college loans $45.09 0.5 $22.54

Queste sono parole chiave che in Google Adwords costano davvero parecchio, ma come vedi nella terza colonna non sempre queste Keywords generato clic e quindi profitto.

Per questo ecco un’altra tabella che ti mostra le parole chiave più redditizie cioè che generano tanti clic,a livello mondiale:
Keyword Cost Per Click Clicks/Day Cost/Day
insurance $17.41 49,893.5 $868,645.81
hotels $3.52 200,636.0 $706,238.75
film $2.88 183,044.0 $527,166.75
home $3.89 102,282.5 $397,878.91
car $5.09 52,069.5 $265,033.75
schools $4.13 60,913.0 $251,570.69
acting $2.28 106,337.0 $242,448.36
credit $8.67 25,705.0 $222,862.34
cheap $2.71 82,139.5 $222,598.05
digital $1.70 130,607.0 $222,031.91
hotel $2.38 84,776.5 $201,768.06
film schools $5.64 35,501.5 $200,228.45
software $3.23 61,259.5 $197,868.19
new $2.17 90,415.0 $196,200.55
auto insurance $29.48 6,453.0 $190,234.44
rental $5.97 31,635.5 $188,863.94
free $1.06 172,680.5 $183,041.33
travel $5.02 35,084.5 $176,124.19
auto $7.28 23,610.5 $171,884.44
video $2.01 83,295.0 $167,422.95
mortgage $13.03 12,172.0 $158,601.16
flights $1.91 75,692.0 $144,571.72
editing $2.37 57,747.0 $136,860.39
refinance $20.01 6,827.0 $136,608.27
loans $9.38 13,966.5 $131,005.77
uk $1.43 86,623.5 $123,871.60
computer $3.67 33,043.5 $121,269.64
buy $2.06 58,840.5 $121,211.43
extended stay $20.13 5,758.0 $115,908.54
home insurance $18.75 6,152.0 $115,350.00
training $3.60 31,112.0 $112,003.20
travel insurance $11.29 9,861.0 $111,330.69
cars $3.90 26,198.5 $102,174.15
debt $9.17 11,104.5 $101,828.26
furniture $1.76 57,463.5 $101,135.76

Trackbacks

1. Technotizie.it
2. pligg.com
3. pligg.it
4. www.upnews.it
5. feedburner.it
6. BlocNum.com
7. rankalo.net
8. pligg.com
9. Anonimo
10. www.pubblicanews.it

Pionieri dell'informatica

2011-02-09T11:15:00.000-08:00

Elenco dei pionieri in informatica

Da Wikipedia, l'enciclopedia libera

Questo articolo presenta un elenco di persone che hanno contribuito alla creazione, allo sviluppo e immaginare di che cosa computer e elettronica potrebbe fare.

Contenuti

Persona	Realizzazione	Ach. Data
John Atanasoff	Costruito il primo computer elettronico digitale, il Atanasoff-Berry Computer, Anche se non era né programmabile né Turing-completo.	1939
Charles Babbage	Progettato il Analytical Engine e costruito un prototipo di meno potente calcolatore meccanico.	1822 1837
John Backus	Inventato FORTRAN (Permula Trantuite), la prima pratica di programmazione ad alto livello linguistico, e ha formulato le Backus-Naur form che ha descritto il linguaggio formale sintassi.	1954 1963
George Boole	Formalizzati Algebra booleana, La base per logica digitale e informatica.	1847 1854
Nikolay Brusentsov	Costruito computer ternario SHENAR.	1958
Vint Cerf e Bob Kahn	Progettato il Transmission Control Protocol e Internet Protocol (TCP / IP), I dati primari protocolli di comunicazione della Internet e altri reti di computer.	1978
Alonzo Church	Fondata contributi alla scienza informatica teorica, in particolare per lo sviluppo del lambda calcolo e la scoperta del indecidibilità problema all'interno di esso.	1936
Wesley Clark A.	Progettato LINC, Il primo computer funzionante in scala verso il basso e un prezzo per il singolo utente. Messo in servizio nel 1963, molte delle sue caratteristiche sono visti come prototipi di quello che dovevano essere gli elementi essenziali dei personal computer.	1962
Edmund M. Clarke	Sviluppato model checking e la verifica formale di software e hardware con E. Allen Emerson.	1981
Edgar F. Codd	Proposto e formalizzato la modello relazionale di gestione dei dati, la base teorica di basi di dati relazionali.	1970
Stephen Cook	Formalizzata la nozione di NP-completezza, ispirando un grande sforzo di ricerca in teoria della complessità computazionale.	1971
James Cooley	Con John W. Tukey, Ha creato il Fast Fourier Transform.	1965
Ole-Johan Dahl	Con Kristen Nygaard, Ha inventato il proto-oggetto linguaggio orientato SIMULA.	1962
Edsger Dijkstra	progressi compiuti in algoritmi, Goto considerato nocivo, Il semaforo (programmazione), rigore, E la pedagogia.	1968
J. Presper Eckert	Con John Mauchly, Progettato e costruito la ENIAC, Il moderno, di prima (tutte elettronico, Turing-completo) computer, e il UNIVAC I, Il primo computer disponibile in commercio.	1943 1951
E. Allen Emerson	Sviluppato model checking e la verifica formale di software e hardware con Edmund M. Clarke.	1981
Douglas Engelbart	Meglio conosciuto per aver inventato il mouse del computer (in uno sforzo congiunto con Bill in inglese), come un pioniere dell'interazione uomo-computer il cui gruppo ha sviluppato Augment ipertesto, computer collegati in rete, E precursori di GUI.	1963
Tommy Flowers	Progettato e costruito la Mark 1 e le dieci migliori Mark 2 Colosso computer, Il primo al mondo programmabile, digitale, elettronica, informatica dispositivi.	1943
Gottlob Frege	Sviluppato primo ordine di calcolo dei predicati, Che è stato precursore di un requisito fondamentale per poter sviluppare la teoria di calcolo.	1879
Seymour Ginsburg	Dimostrato "don't-care"Minimizzazione del circuito non deve necessariamente portare a risultati ottimali, hanno dimostrato che ALGOL linguaggio di programmazione è context-free (così da legare teoria dei linguaggi formali al problema della compilatore scrittura), e inventato AFL Teoria.	1958 1961 1967
Kurt Gödel	Dimostrato che Peano aritmetica assiomatizzata non poteva essere sia logicamente coerente e completa in primo ordine di calcolo dei predicati. Chiesa, Kleene, Turing e sviluppato le basi della teoria di calcolo basato sulla corollari al lavoro di Gödel.	1931
Lois Haibt	Era un membro del team persona che ha inventato dieci Fortran e tra le prime donne a svolgere un ruolo cruciale nello sviluppo della scienza informatica.	1954
C.A.R. Hoare	Ha sviluppato il linguaggio formale Comunicare processi sequenziali (CSP) e Quicksort.	1960 1978
Grace Hopper	lavori avviati sulla necessità di linguaggi di programmazione ad alto livello, che ha definito programmazione automatica, E ha scritto l'A-O compilatore, Che condiziona fortemente la COBOL lingua.	1952
Cuthbert Hurd	Ha aiutato la International Business Machines Corporation sviluppare il suo primo computer general-purpose, l' IBM 701.	1952
Kenneth E. Iverson	Aiutato nella istituisce il primo corso di laurea in informatica (a Harvard) E ha insegnato quel corso; inventato il APL linguaggio di programmazione e contributo al calcolo interattivo.	1954; 1962
Jacek Karpinski	Sviluppato il primo analizzatore differenziale che usate di transistor, e sviluppato una delle prima macchina algoritmi di apprendimento per il carattere e il riconoscimento delle immagini. È stato anche l'inventore di uno dei primi minicomputer, il K-202.	1973
Alan Kay	molte delle idee alla base dei linguaggi di programmazione object-oriented Introdotti, ha guidato il team che ha sviluppato Smalltalk, e ha dato contributi fondamentali per il personal computing.	1970~
Stephen Cole Kleene	Lanciato il lavoro con Alonzo Church sul Lambda Calculus che per primo ha gettato le basi della teoria della computazione.	1936
Donald Knuth	Ha scritto The Art of Computer Programming e ha creato TeX.	1968 1989
Leslie Lamport	Formulato algoritmi per risolvere molti problemi fondamentali nei sistemi distribuiti (ad esempio il panificio algoritmo). Sviluppato il concetto di un clock logico, Che permette la sincronizzazione tra entità distribuite in base agli eventi attraverso il quale comunicare.	1974 1978
Sergei Lebedev Alekseyevich	Indipendentemente progettato il primo computer elettronico in Unione Sovietica, MESM, A Kiev, Ucraina.	1951
Gottfried Leibniz	progressi della logica simbolica, come la Calcolo ratiocinator, Che sono stati pesantemente influenti sulla Gottlob Frege. sviluppi Made in primo ordine di calcolo dei predicati che sono stati cruciali per i fondamenti teorici dell'informatica.	1670~
Ramon Llull	Progettato più macchine simboliche rappresentazioni, e pioniere nozioni di rappresentazione simbolica e la manipolazione di produrre conoscenza, sia dei quali sono stati influenze principali su Leibniz.	1300~
J. C. R. Licklider	Ha iniziato l'indagine dell'interazione uomo-computer, portando a molti progressi nelle interfacce del computer così come in cibernetica e intelligenza artificiale.	1960
Ada Lovelace	Ha iniziato lo studio del calcolo scientifico, analizzando il lavoro di Babbage nel suo Disegno della macchina analitica, Ed è stata la omonimo per la Ada linguaggio di programmazione.	1843
John Mauchly	Con J. Presper Eckert, Progettato e costruito la ENIAC, Il moderno, di prima (tutte elettronico, Turing-completo) computer, e il UNIVAC I, Il primo computer disponibile in commercio.	1943 1951
John McCarthy	Inventato LISP, Un linguaggio di programmazione funzionale.	1955
Marvin Minsky	Co-fondatore di Artificial Intelligence Lab a Massachusetts Institute of Technology , Autore di numerosi testi su AI e la filosofia.	1963
Max Newman	Istigato la produzione del Colosso computer a Bletchley Park. Dopo la guerra fondò la Macchina Laboratorio di Informatica presso il Università di Manchester dove il primo al mondo A programma memorizzato computer, Il Manchester Machine Small-Scale Experimental è stato inventato.	1943
John von Neumann	Ha ideato il architettura di von Neumann su cui i computer più moderni sono basati.	1945
Kristen Nygaard	Con Ole-Johan Dahl, Ha inventato il proto-oggetto linguaggio orientato SIMULA.	1962
Emil L. Post	Sviluppato il Post macchina come un modello di calcolo, indipendentemente da Turing. Conosciuto anche per lo sviluppo verità tabelle, Il Post corrispondenza problema utilizzati nella teoria della ricorsione e dimostrare ciò che è noto come teorema di Post.	1936
Gerard Salton	Un pioniere di automatica Information Retrieval, Che ha proposto la vettore nello spazio modello e il invertita indice.	1975
Dennis Ritchie e Ken Thompson	Ha aperto la strada C linguaggio di programmazione e il UNIX computer il sistema operativo dei Bell Labs.	1967
Claude Shannon	Fondata teoria dell'informazione e pratico progettazione di circuiti digitali.	1937 1948
Herbert Simon	Uno scienziato politico ed economista che per primo intelligenza artificiale. Co-ideatore del Logic Theory Machine e il General Problem Solver programmi.	1956 1957
Ivan Sutherland	Autore di Album per schizzi, L'antenato del moderno computer-aided redazione (CAD) programmi e uno dei primi esempi di programmazione orientata agli oggetti.	1963
John W. Tukey	Con James Cooley, Ha creato il Fast Fourier Transform.	1965
Alan Turing	Dato un contributo alla scienza fondazione diversi computer, compreso il Macchina di Turing computazionale del modello, e ACE design.	1936
Maurice Wilkes	Costruito il primo pratico programma registrato computer (EDSAC) Da completare e per essere accreditato con le idee di diversi linguaggi di programmazione ad alto livello costrutti.	1949
Niklaus Wirth	Progettato il Pascal, Modula-2 e Oberon linguaggi di programmazione.	1970 1978
Konrad Zuse	Costruì il primo computer funzionante nastro a programma memorizzato-controllato, il Z3. La Z3 è stato dimostrato di essere alla completezza di Turing nel 1998.	1941

Lista dei più grandi programmatori

2011-02-09T11:12:00.000-08:00

A

Scott Adams - Uno dei primi sviluppatori di CP / M e DOS Giochi
Leonard Adleman - Co-creatore di RSA algoritmo (il A nel nome sta per Adleman), ha coniato il termine computer virus
Alfred Aho - Co-creatore di AWK (Il A nel nome sta per Aho "), e autore principale del famoso Dragon libro
JJ Allaire - Creatore di ColdFusion Application Server, ColdFusion Markup Language
Paul Allen - Altair BASIC, Applesoft BASIC, Co-fondatore Microsoft
Eric Allman - sendmail, syslog
Marc Andreessen - Co-creatore di Mosaico, Co-fondatore di Netscape
Bill Atkinson - QuickDraw, HyperCard

B

John Backus - FORTRAN, BNF
Richard Bartle - MUD, Con Roy Trubshaw, Creatore del MUD
Brian Behlendorf - Apache
Kent Beck - Creato Extreme Programming e co-creatore di JUnit
Donald Becker - Linux Ethernet conducenti, La leggenda di Beowulf clustering
Doug Bell - Dungeon Master serie di giochi per computer
Fabrice Bellard - Creatore di FFMPEG Open Library codec, QEMU strumenti di virtualizzazione
Tim Berners-Lee - Inventore di World Wide Web
Daniel J. Bernstein - djbdns, qmail
Eric Bina - Co-creatore di Mosaic browser web
Marc Blank - Co-creatore di Zork
Joshua Bloch - Core designer linguaggio Java, il piombo Java collezioni quadro progetto
Bert Bos - Autore di Argo browser web, co-autore di Fogli di stile CSS
David Bradley - Codificatore sul IBM PC progetto Team che ha scritto il Control-Alt-Canc tastiera gestore, incorporato in tutti i PC-compatibili BIOS
Andrew Braybrook - Videogiochi Paradroid e Uridium
Larry Razza - Co-sviluppatore di APL \ 360
Jack E. Bresenham - Creatore di linea algoritmo di Bresenham
Dan Bricklin - Co-creatore di VisiCalc, La prima personale foglio elettronico programma
Walter Bright - Digital Mars, Primo compilatore C + +, autore di D (linguaggio di programmazione).
Richard Brodie - Microsoft Word
Grady Booch - Co-creatore di Unified Modeling Language
Andries Brouwer - Hack, Ex manutentore uomo cercapersone man (1), Linux kernel hacker
Danielle Berry Bunten (Dani Bunten) - M.U.L.E., Gioco multiplayer video
Dries Buytaert - Creatore di Drupal

C

Steve Capps - Co-creatore di Macintosh e Newton
John D. Carmack - sparatutto in prima persona Destino, Tremito
Vinton Cerf - TCP / IP, NCP
Ward Christensen - Ha scritto la prima BBS (Bulletin Board System) CBBS sistema
Bram Cohen - BitTorrent protocollo di progettazione e attuazione
Alain Colmerauer - Prolog
Alan Cooper - Visual Basic
Alan Cox - Co-sviluppatore di Linux kernel
Brad Cox - Objective-C
Mike Cowlishaw - REXX e NetRexx, Lexx editor, Elaborazione di immagini, decimale aritmetica dei pacchetti
Mark Crispin - Creatore di IMAP, Autore di UW-IMAP, una delle implementazioni di riferimento di IMAP4
Pamela Crossley - Creatore di SIMPLE per la gestione accademica di pagine web
Ward Cunningham - Creatore di Wiki concetto
William Crowther - Avventura Colossal Cave
Dave Cutler - Architetto di VMS, Windows NT

D

Ole-Johan Dahl - Co-creatore di SIMULA
James Duncan Davidson - Creatore di Micio, Ora parte di Jakarta Project
L. Peter Deutsch - Ghostscript, Assembler per PDP-1, XDS-940 timesharing sistema, QED originale co-autore
Edsger Dijkstra - Contributi a ALGOL, algoritmo di Dijkstra, Goto Considered Harmful
Matt Dillon - Programmatore di vari software tra cui DICE e DragonflyBSD
Martin Dougiamas - Ideatore e sviluppatore di piombo Moodle
Adam Dunkels - Autore di Contiki sistema operativo, il lwIP e LinuxIT embedded stack TCP / IP, inventore del protothreads

E

Les Earnest - Autore di dito programma
Brendan Eich - Creatore di JavaScript
Larry Ellison - Co-creatore di Oracle database, Co-fondatore di Oracle Corporation
Marc Ewing - Creatore di Red Hat Linux

F

Dan Farmer - Creatore di COPS e SATANA Security Scanner
Stuart Feldman - Creatore di fare, Autore di Fortran 77 compilatore, parte del gruppo originale che ha creato Unix
David Filo - Co-creatore di Inizio
Brad Fitzpatrick - Creatore di memcached, Livejournal e OpenID
Andrew Fluegelman - Autore PC-Talk software di comunicazione, è considerato un co-creatore di shareware
Brian Fox - Creatore di Bash, Readline, GNU Dito, Meta-HTML
Jim Fruchterman - Fondatore di Arkenstone (ora parte della Freedom Scientific) E Benetech, Scanner creato per cieco persone

G

Elon Gasper - Co-fondatore Bright Star Technology, Brevettato realistici movimenti facciali per il parlato in-game. HyperAnimator, Alphabet Blocks, Ecc
Bill Gates - Altair BASIC, Co-fondatore Microsoft
Steve Gibson - Creatore di SpinRite
John Gilmore - GDB
Adele Goldberg - Co-creatore di Smalltalk
Ryan C. Gordon (Pseudonimo Icculus) - Lokigames, ioquake3, MojoSetup, Ecc
James Gosling - Java, Gosling Emacs, NeWS
Bill Gosper - Macsyma, Lisp macchina, hashlife, Ha contribuito Donald Knuth su di Vol.2 The Art of Computer Programming (Algoritmi semi-numerica)
Andrew Gower - RuneScape Classic, RuneScape, Co-fondatore Jagex
Paul Gower - RuneScape Classic, RuneScape, Co-fondatore Jagex
Paul Graham - Inizio Store, Il Lisp, ANSI Common Lisp
John Graham-Cumming - Autore di POPFile, Un Filtro bayesianoA base di classificatore e-mail
Ralph Griswold - Co-creatore di SNOBOL, Creatore di Icon (linguaggio di programmazione)
Richard Greenblatt - Lisp macchina, Incompatibile sistema timesharing, MacHack
Scott Guthrie, (Pseudonimo ScottGu) - ASP.NET Creator
Andi Gutmans - Co-creatore di PHP linguaggio di programmazione

H

Jim Hall - Ha avviato l' FreeDOS progetto
David Heinemeier Hansson - Ha creato la Ruby on Rails quadro di riferimento per lo sviluppo di applicazioni web.
Albert David Huffman - Ha creato la Codice di Huffman Algoritmo di compressione.
Rebecca Heineman - Autore di Bard's Tale III: Thief of Fate e Dragon Wars.
Anders Hejlsberg - Turbo Pascal, Borland Delphi, C #
Ted Henter - Fondatore di Henter-Joyce (ora parte di Freedom Scientific) Creatore di Fauci, screen reader software per non vedenti
Andy Hertzfeld - Co-creatore di Macintosh, Co-fondatore di General Magic, Co-fondatore di Eazel
Rich Hickey - Creatore di Clojure lingua
D. Richard Hipp - Creatore di SQLite
C. A. R. Hoare - Prima implementazione di Quicksort, ALGOL 60 compilatore, Comunicare processi sequenziali
James Holmes - Committer su Struts progetto, creare di Struts Console
Grace Hopper - Harvard Mark I computer, FLOW-MATIC, COBOL
Dave Hyatt - Co-autore di Mozilla Firefox

I

Miguel de Icaza - GNOME project leader, iniziatore di Mono progetto
Roberto Ierusalimschy - Lua famoso architetto
Dan Ingalls - Co-creatore di Smalltalk e BitBlt
Geir Ivarsøy - Co-creatore di Opera web browser
Ken Iverson - APL, J
Toru Iwatani - Creatore di Pac-Man

J

Bo Jangeborg - Sinclair ZX Spectrum Giochi
Paul Jardetzky - Autore del programma server per la prima webcam
Lynne Jolitz - 386BSD
William Jolitz - 386BSD
Rod Johnson - creatore di Spring Framework
Stephen C. Johnson - yacc
Bill Joy - BSD, csh, VI, Co-fondatore di Sun Microsystems
Robert K. Jung - Creatore di ARJ

K

Mitch Kapor - Lotus 1-2-3, Fondata Lotus Development Corporation
Phil Katz - Creatore di File in formato ZIP, Autore di PKZIP
Alan Kay - Smalltalk, Dynabook, programmazione orientata agli oggetti, Squittio
Mel Kaye - Un Vero Programmatore^[1]
John Kemeny - Co-creatore di BASIC
Stan Kelly-Bootle - Manchester Mark 1, DP Il dizionario del diavolo
Brian Kernighan - Co-creatore di AWK (Il K nel nome sta per Kernighan), autore di ditroff strumento di formattazione del testo
Gary Kildall - CP / M
Tom Knight - Incompatibile sistema timesharing
Jim Knopf - Aka Jim Bottone, autore PC-File flatfile database; considerato un co-creatore di shareware
Donald E. Knuth - TeX, CWEB, Metafont, The Art of Computer Programming, Concrete Mathematics

L

Tom Lane - Autore principale di libjpeg, Sviluppatore principale di PostgreSQL
Leslie Lamport - LaTeX
Butler Lampson - QED originale co-autore
Sam Lantinga - Creatore di SDL
Dick Lathwell - Co-sviluppatore di APL \ 360
Chris Lattner - Autore principale di Low Level Virtual Machine progetto
Samuel J Leffler - BSD, FlexFAX, libtiff, I driver di periferica FreeBSD Wireless
Rasmus Lerdorf - Creatore originale di PHP
Michael Lesk - Lex
Gordon Letwin - Architetto OS / 2, Autore di HPFS file di sistema
Håkon Wium Lie - Co-autore di Fogli di stile CSS
Robert Love - Linux kernel sviluppatore
Ada Lovelace - Prima programmatore (di Charles Babbages' Analytical Engine)
Al Lowe - Creatore di Leisure Suit Larry serie

M

Raphael Manfredi - Contributi a Perl, Architetto software e manutentore di gtk-gnutella
Khaled Mardam-Bey - Creatore di mIRC (Internet Relay Chat client)
Yukihiro Matsumoto - Ruby
John McCarthy - Lisp
Craig McClanahan - Autore originale di Jakarta Struts, Architetto di Tomcat Catalina servlet container
Daniel D. McCracken - Professore City College e autore di Guida alla Algol Programmazione, Guida alla Cobol Programmazione, Guida alla Fortran Programmazione (1957)
Douglas McIlroy - tubi e filtri, Concetto di software componentistica, Unix strumenti (incantesimo, diff, ordinare, unire, grafico, parlare, tr, etc)
Shawn McKenzie - AutoTheme
Marshall Kirk McKusick - BSD, Il lavoro di FFS, Implementatori di aggiornamenti soft
Bertrand Meyer - Eiffel, Object-Oriented Software Construction, Design by Contract
Bob Miner - Co-creatore di Oracle database, Co-fondatore di Oracle Corporation
Jeff Minter - Psychedelic, e spesso lamaConnessi video giochi
Lou Montulli - Creatore di Lince browser, cookies, Il tag blink, spingere e tirare client server, proxy HTTP, HTTP su SSL, integrazione con il browser con GIF animate, membro fondatore del gruppo di lavoro su HTML W3C
Bram Moolenaar - Autore di editor di testo Vim
David Moon - MACLISP, ZetaLisp
Charles H. Moore - Creatore di Via lingua
Roger Moore - Co-sviluppatore di APL \ 360, Creatore di IPSANET, Co-fondatore di I.P. Sharp Associates
Mike Muuss - Autore di ping, Strumento di rete per rilevare host

N

Patrick Naughton - Inizio Java progettista, xlock, HotJava
Peter Naur - Backus-Naur form, ALGOL 60
Col Needham - Creatore di Internet Movie Database (IMDb)
Graham Nelson - Creatore di Informare sistema di authoring per Interactive fiction
Peter Norton - Programmatore del famoso programma di file manager, Norton Commander
Kristen Nygaard - SIMULA

O

Ed Oates - Co-creatore di Oracle database, Co-fondatore di Oracle Corporation
Steve O'Donnell - Fondatore di GOAL Systems, sviluppatore leader di WDU, Westi, Creater indipendenti DOS programmi di utilità, sviluppatore di Prompt
Jarkko Oikarinen - Creatore di Internet Relay Chat (IRC)
Andrea e Filippo Oliver, Il Oliver Twins - Molti Sinclair ZX Spectrum giochi tra cui Vertiginoso
John Ousterhout - Creatore di Tcl/Tk
Mark Overmars - Professore, ben noto per la creazione di Game Maker
Onel de Guzman - Un programmatore filippino, la cui crea il virus ILOVEYOU il 4 maggio 2000.

P

Alexey Pajitnov - Creatore di gioco Tetris su Electronica 60
Seymour Papert - Logo (linguaggio di programmazione)
Tim Paterson - Autore di 86-DOS (QDOS)
Jeffrey Peterson - Chiave sorgente del software libero e open architetto, creatore di Quepasa
Charles Petzold - Autore di molti Microsoft Windows programmazione libri
Rob Pike - Ha scritto prima bitmap sistema a finestre per Unix, co-creatore di UTF-8 la codifica dei caratteri, autore di editor di testo sam e ambiente di programmazione acme, Principale autore di Plan 9 e Inferno sistemi operativi
Kent Pitman - Collaboratore tecnico al ANSI Common Lisp standard
Larry Page - Co-fondatore di Google, Inc

Q

R

Theo de Raadt - Socio fondatore della NetBSD, Fondatore della OpenBSD e OpenSSH
Jef Raskin - Ha avviato l' Macintosh progetto in Apple Computer, Intese Canon Cat computer, sviluppato L'ambiente umano programma
Eric Raymond - Movimento Open Source, Autore di fetchmail
Hans Reiser - Creatore di ReiserFS file di sistema
John Resig - Creatore e sviluppatore principale di jQuery Libreria JavaScript
Craig Reynolds - Creatore di boids computer grafica di simulazione
Dennis Ritchie - C, Unix, Plan 9 dei Bell Labs, Inferno
Ron Rivest - Co-creatore di RSA algoritmo (il R nel nome è l'acronimo di Rivest)
John Romero - sparatutto in prima persona Destino, Tremito
Blake Ross - Co-autore di Mozilla Firefox
Guido van Rossum - Python
Jeff Rulifson - Programmatore di piombo sul NLS progetto
Rusty Russell - Creatore di iptables per linux
Steve Russell - Primo Lisp interprete; originale Spacewar! gioco per computer grafica.

S

Bob Sabiston - Rotoshop, Interpolando rotoscope Software di animazione
Sakya Muni - Software nepalese
Carl Sassenrath - Amiga, REBOL
Chris Sawyer - Sviluppo di Roller Coaster Tycoon e il Transport Tycoon serie
Bill Schelter - GNU Maxima, GNU Common Lisp
Randal L. Schwartz - Solo un altro hacker Perl
Adi Shamir - Co-creatore di RSA algoritmo (il S nel nome sta per Shamir)
Mike Shaver - Socio fondatore della Mozilla Organization
Cliff Shaw - IPL, La lingua AI primo
Zed Shaw - Ha scritto la Mongrel Web Server, Per le applicazioni web Ruby.
Emily Short - Prolifico scrittore di Interactive fiction e co-sviluppatore di Informare versione 7
Jacek Sieka - Sviluppo di DC + + un open-source, peer-to-peer file-sharing client
Ken Silverman - Creatore di Duke Nukem 3D'S motore grafico
Charles Simonyi - notazione ungherese, Microsoft Word
Colin Simpson - Sviluppatore di CircuitLogix Software di simulazione
Rich Skrenta - Co-fondatore di Open Directory Project
Matthew Smith - Sinclair ZX Spectrum giochi, compresi Manic Miner e Jet Set Willy
Henry Spencer - C News, Regex
Quentin Stafford-Fraser - Autore di originali VNC spettatore, prima di Windows server VNC, il programma client per la prima webcam
Richard Stallman - Emacs, GCC, GDB, Fondatore e pioniere di GNU Progetto, indipendente dal terminale I / O su Pioneer ITS, Lisp macchina manuale (chineual)
Guy Steele - Common Lisp, Regime
Alexander Stepanov - Creatore di Standard Template Library
Bjarne Stroustrup - C + +
Zeev Suraski - Co-creatore di PHP lingua
Gerald Jay Sussman - Regime
Tim Sweeney - L'Unreal Engine, UnrealScript, ZZT

T

Andrew Tanenbaum - Minix
Audrey "Autrijus" Tang - Designer di Carlini
Simon Tatham - NASM, PuTTY
Larry Tesler - L' PUB linguaggio di markup, Il Smalltalk Il codice del browser, debugger e oggetto di ispezione, e (con Tim Mott) Il Zingaro word processor
Jon Stephenson von Tetzchner - Co-creatore di Opera web browser
Avie Tevanian - Autore di Mach kernel
Ken Thompson - Disegnatore principale e autore di Unix, Plan 9 e Inferno sistemi operativi, B e lingue Bon (precursori di C), Creatore di UTF-8 la codifica dei caratteri, ha introdotto espressioni regolari in QED.
Michael Tiemann - G + +, GCC
Linus Torvalds - Autore originale e attuale responsabile della Linux kernel e creatore di Git, Un codice sorgente del sistema di gestione
Leonard H. Tower Jr. - GCC E GNU diff
Michael Toy - Co-sviluppatore del gioco per computer Furfante
Andrew Tridgell - Samba, Rsync
Roy Trubshaw - MUD - Insieme con Richard Bartle, Creatore del MUD
Bob Truel - Co-fondatore di Open Directory Project

U

V

Wietse Venema - Postfix, SATANA, TCP Wrapper
Paul Vixie - BIND, Cron
Patrick Volkerding - Original autore e l'attuale responsabile della Slackware Distribuzione Linux

W

Larry Wall - Warp (1980 spazio gioco-guerra), rn, patch, Perl
Bob Wallace - Autore PC-Write word processor, è considerato un co-creatore di shareware
John Walker - Co-fondatore di Autodesk
John Warnock - Creatore di PostScript
Pei-Yuan Wei - Autore di Viola, Uno dei primi browser grafici
Peter J. Weinberger - Co-creatore di AWK (Il W nel nome sta per Weinberger)
Andrew Welch - Autore di Gorgo, Snapz Pro; Fondatore di Ambrosia Software
David Wheeler - Co-creatore di sottoprogramma; Progettista di WAKE, Co-progettista di Tiny Encryption Algorithm, XTEA, Burrows-Wheeler trasformi.
Arthur Whitney - A +, K
Bruce Wilcox - Creatore di Computer Go, programmato NEMESIS Go Master.
Evan Williams Ideatore e co-fondatore di Twitter
Roberta e Ken Williams -- Sierra Entertainment, King's Quest, Gioco di avventura grafica
Sophie Wilson - Designer di set di istruzioni per Acorn RISC Machine, Autore di BBC BASIC.
Dave Winer - Sviluppato XML-RPC, Frontier linguaggio di scripting
Niklaus Wirth - Pascal, Modula-2, Oberon
Stephen Wolfram - Creatore di Mathematica
Don Bosco - INTERCAL, Colossal Cave Adventure
Steve Wozniak - Breakout, Apple Integer BASIC, Co-fondatore di Apple Inc.
Will Wright - Ha creato la serie Sim City e co-fondatore di Maxis

X

Y

Jerry Yang - Co-creatore di Inizio
Victor Yngve - Autore della prima lingua l'elaborazione delle stringhe, COMIT

Z

Jamie Zawinski - Lucid Emacs, Netscape, Mozilla, XScreenSaver
Philip Zimmermann - Creatore di software di crittografia PGP, Il ZRTP protocollo, e Zfone

Logistoris

KPI - INDICATORI CHIAVE DI PERFORMANCE

link a rss

xmplparser esempio php

trucchi ed esempi php

leggere feed

Fedd rss

Specifiche RSS 2.0

Che cos'è l'RSS?

File di esempio

Informazioni su questo documento

Elementi obbligatori per channel

Elementi opzionali per channel

<image> sub-element of <channel>

<cloud> sub-element of <channel>

<ttl> sub-element of <channel>

<textInput> sub-element of <channel>

Elementi per <item>

<source> sub-element of <item>

<enclosure> sub-element of <item>

<category> sub-element of <item>

<pubDate> sub-element of <item>

<guid> sub-element of <item>

<comments> sub-element of <item>

<author> sub-element of <item>

Commenti

Estendere l'RSS

Roadmap

Utilizzare hastable in javascript

Come Creare Un Blog

Come Creare Un Blog: Le Migliori Piattaforme di Pubblicazione Online Gratuite

WordPress

Blogger

Windows Live Spaces

LiveJournal

Vox

Xanga

Tripod

Blog.com

Yahoo! Pulse

Blogr

Squarespace

TypePad

DBlog

Blog:CMS

Questo-è-un-blog-sulla-SEO

Friday, January 14, 2011

Come disattivare la cache di Firefox?

Come disattivare la cache di Firefox?

Gli eseguibili di PostgreSQL

Gli eseguibili di PostgreSQL

postgres

psql

clusterdb

createdb

createlang

createuser

dropdb

droplang

dropuser

ecpg

initdb

ipcclean

pg_config

pg_controldata

pg_ctl

pg_dump

pg_dumpall

pg_resetxlog

pg_restore

reindexdb

vacuumdb

Linux copie

Il pg_dump

Notepad per php con debugger

problemi di concorrenza

sviluppo di un business online

seo doctor

parole chiave

Pionieri dell'informatica