[successivo] [precedente] [inizio] [fine] [indice generale] [violazione GPL] [translators] [docinfo] [indice analitico] [volume] [parte]

Capitolo 215.   Le basi del linguaggio

Per poter scrivere codice in un qualunque linguaggio è necessario conoscerne la sintassi. In questo capitolo verranno trattate le espressioni fondamentali del PHP con il supporto di script di esempio.

215.1   La sintassi

In realtà <?php ?> non sono gli unici marcatori per fornire codice all'interprete. Ecco tutti i modi di includere codice PHP negli script:

Il primo è disponibile solo se sono stati impostati i marcatori abbreviati, ciò può essere fatto abilitando nel file di configurazione php.ini l'opzione short_open_tag. Per i particolari sugli altri marcatori si rimanda al manuale ufficiale.

Va sottolineato che il codice può essere bloccato e ripreso in ogni punto dello stesso file, ad esempio:

1  <html>
2     <head>
3
4        <? $nome = "BRDP"; ?>
5        <title>ancora agli inizi</title>
6
7     </head>
8     <body>
9
10       <br>Ciao a tutti questo è il mio nome: <?=$nome ?>
11
12    </body>
13 </html>

Nell'esempio il codice viene aperto per la prima volta nella riga 4, viene assegnato un valore alla variabile $nome, viene chiuso e poi riaperto nella riga 10 dove viene visualizzato a schermo il valore della variabile insieme a una frase HTML. Il file quindi restituirà come output la stringa:

   Ciao a tutti questo è il mio nome: BRDP

Con l'occasione, nell'esempio, sono stati toccati due concetti base.

Il primo è che le variabili in PHP iniziano con il carattere $ e sono sensibili a maiuscole e minuscole, l'altro è che non è necessario definirne il tipo, sarà quello del primo dato ad essa assegnato. Nel nostro caso la variabile $nome, dalla riga 4 in poi, sarà considerata una stringa. Per averne conferma basta sostituire il codice della riga 4 con le due righe seguenti:

4  <?
5     $nome = "BRDP";
6     echo gettype($nome);
7  ?>

Il risultato è:

   string
   Ciao a tutti questo è il mio nome: BRDP

Più avanti si apprenderà come trattare i vari tipi di dati, quindi è inutile dilungarsi in questo esempio; bisogna però dire che è possibile cambiare il tipo di dati mediante l'istruzione:

   settype($variabile, tipo_variabile);

e ottenere il tipo di dato contenuto in una variabile tramite:

   gettype($variabile);

Il secondo concetto è nella riga 10; per visualizzare il contenuto della variabile è stata utilizzata la sintassi:

   <?=$nome ?>

Per chi si avvicina al PHP dopo aver sviluppato in Perl o in altri linguaggi script CGI la differenza è lampante. Non è necessario scrivere codice per generare HTML, semplicemente si inserisce codice PHP tra i marcatori HTML. Inoltre nel caso in cui l'istruzione sia la semplice visualizzazione di una singola variabile, la sintassi classica:

   <? echo $nome ?>

può essere abbreviata con:

   <?=$nome ?>

Attenzione: se il codice PHP è formato da più istruzioni consecutive è richiesto il carattere punto e virgola (;) alla fine di ognuna di esse, se invece l'istruzione da inserire è una sola, il ; può essere omesso.

Sarebbe buona norma dedicare molta cura all'indentazione del codice e inserire commenti chiari e diretti; così facendo si rende il codice più leggibile e comprensibile. La gestione dei commenti è simile a quella utilizzata in C, C++ e shell di Unix. I caratteri di commento sono: per una singola riga // la barra obliqua doppia oppure il carattere #, per più righe il commento viene aperto con /* e chiuso con */. Nel secondo caso bisogna fare attenzione a non annidare i commenti. Questo è il modo corretto:

0    <?
1      // Questo è un commento su una singola riga
2      // adesso visualizzo ciao mondo!
3 
4         echo "ciao mondo!";
5
6      /* 
7         questo è un commento
8         su più righe, posso scrivere di tutto!!!
9         anche istruzioni php che non verranno interpretate come: 
10        echo "questo non verrà visualizzato!";
11        chiudo il commento
12     */
13
14        echo "<br>questo invece si vedrà!!";
15
16     /* 
17        Notare che ho inserito <br> un marcatore html nel
18        codice php! Posso farlo.
19     */
20   ?>

Questo è sbagliato:

0   <?
1
2     /* 
3         echo "ciao mondo!"; /* questo causa problemi! */ 
4     */
5 
6   ?>

215.2   Primo script

Come primo esempio verrà realizzata una pagina di riconoscimento del visitatore. Il PHP fornisce una serie di «variabili predefinite». Tra esse ce ne sono alcune fornite dal protocollo HTTP.

Per l'elenco completo delle variabili predefinite è bene consultare il manuale ufficiale del PHP, molte di esse vengono visualizzate nella pagina generata dalla funzione phpinfo() (1)

Il primo passo è scegliere le variabili da utilizzare.

Per questo semplice script verranno utilizzate:

è importante fare molta attenzione all'utilizzo di queste variabili, alcune di esse usate in modo superficiale potrebbero fornire informazioni utili ai malintenzionati. Ad esempio DOCUMENT_ROOT fornisce la directory su file system in cui si trovano gli script PHP e i documenti del servizio HTTP. Informazioni di questo tipo è meglio tenerle riservate!

Scelte le variabili va creato il nuovo file e salvato con il nome di benvenuto.php. La prima versione, la più rudimentale, è la seguente:

1  <html>
2     <head>
3        <title>Benvenuto!</title>
4     </head>
5     <body>
6
7        <br> La mia prima vera pagina in PHP.<br><hr>
8
9        <br><br> Informazioni sul server:              
10       <br>Sei giunto  su: <?=$SERVER_NAME ?>
12       <br>Stai eseguendo lo script: <?=$SCRIPT_NAME ?>
13
14       <br><br> Esaminiamo il client: 
15
16       <br> Indirizzo IP: <?=$REMOTE_ADDR ?>
17       <br> Vedo che provieni da: <?=$HTTP_REFERER ?>
18       <br> Tipo di browser: <?=$HTTP_USER_AGENT ?>
19 
20    </body>
21 </html>

Salvato il file nella directory del servizio HTTP e richiamato dal navigatore si ottiene qualcosa simile a:

  La mia prima vera pagina in PHP.

  Informazioni sul server:
  Sei giunto su: www.urcanet.it
  Stai eseguendo lo script: /brdp/php_manual/esempi/cap_2/benvenuto.php

  Esaminiamo il client:
  Indirizzo IP: 127.0.0.1
  Vedo che provieni da: http://www.urcanet.it/brdp/php_manual/esempi/cap_1/primo.php
  Tipo di browser: Mozilla/5.0 (X11; U; Linux 2.4.2-2 i686; en-US; 0.7) Gecko/20010316

Anche questo esempio è disponibile in rete all'indirizzo: <http://www.urcanet.it/brdp/php_manual/esempi/cap_2/benvenuto.php>

Il risultato potrebbe essere incomprensibile per i visitatori meno esperti. Ad esempio, il tipo di navigatore non è molto chiaro.

Gli strumenti fin qui trattati non permettono di fare molto per migliorare il risultato dello script. Più avanti questo esempio potrà essere ripreso per manipolare il risultato in modo da mostrare al visitatore dei messaggi più chiari.

215.3   Tipi di dati

Il PHP gestisce quattro tipi scalari, due tipi composti e due tipi speciali di dati.

Tabella 215.1. Questi i tipi di dati gestiti dal PHP.

Scalari Composti Speciali
boolean array resurce
integer object NULL
double
string

Come già accennato in precedenza, il tipo di una variabile può essere modificato in ogni momento con la funzione settype($variabile,tipo) che restituisce un valore booleano vero o falso rappresentante l'esito dell'operazione. I possibili tipi da assegnare alla variabile sono:

I criteri di conversione dei tipi sono molto importanti, il codice mostrato di seguito non provoca problemi.

0  <?
1  $a = 231;   // da questo momento in poi $a è un intero 
2  if(settype($a,double)){
3    /*
4      Se l'operazione è riuscita il valore è TRUE quindi 
5      visualizza il testo seguente. Altrimenti salta alla
6      fine dell'if riga 10.  
7    */
8    echo "<br>valore settato a double. Ecco il nuovo valore: ";
9    echo $a;
10 }
11 ?>

Spiacevoli inconvenienti potrebbero verificarsi se si prova a convertire una stringa in un intero. Per una trattazione più approfondita di questo argomento si rimanda al manuale ufficiale.

Un'altra funzione utile per la gestione dei tipi di dati è gettype($variabile) che restituisce una stringa contenente il tipo della variabile a essa fornita. Questi i possibili valori restituiti dalla funzione:

Ecco un semplice esempio di utilizzo della funzione gettype():

0  <?
1  $a = "brdp";
2  /*
3    la variabile $a è stata 
4    inizializzata come stringa
5  */
6  $tipo_a = gettype($a);  
7  echo "<br>La variabile è di tipo:";
8  echo $tipo_a;
9  ?>

Il risultato dello script sarà:

  La variabile è di tipo: string

Dopo questa breve trattazione sulla gestione dei tipi di dati a disposizione nel PHP, è bene accennare alle caratteristiche di ognuno di essi.

215.3.1   integer

Il tipo di dati integer rappresenta tutti i numeri dell'insieme matematico degli interi.

     Z = {..., -2, -1, 0, 1, 2, ...}

Quindi tutti i numeri interi, sia negativi che positivi, vengono gestiti dal PHP come tipi integer.

Anche i corrispondenti valori in base otto e sedici vengono gestiti come gli interi. Ecco alcuni esempi tratti dal manuale ufficiale:

<?
   $a = 1234;     // numero intero positivo
   $a = -123;     // numero intero negativo
   $a = 0123;     // numero ottale (equivalente a 83 in decimale)
   $a = 0x1A;     // numero esadecimale (equivalente a 26 in decimale)
?>

Il limite massimo della dimensione dei valori interi dipende dall'architettura dell'elaboratore su cui si lavora.

Nel PHP non esiste un tipo specifico per i numeri naturali.(3) Essi vengono gestiti come integer.

215.3.2   boolean

Il tipo di dati boolean può assumere solo due valori, vero o falso.

Questo tipo viene utilizzato frequentemente per la gestione degli errori. Molte funzioni, infatti, restituiscono un valore booleano che assume valore vero se l'operazione è andata a buon fine, falso se si è verificato un errore.

Per assegnare il valore vero o falso a una variabile è sufficiente l'istruzione:

  $bit = True;

In questo esempio alla variabile $bit è stato assegnato il valore vero. Anche se l'istruzione if non è ancora stata trattata, è necessario anticipare le metodologie di controllo sul valore della variabile.

In PHP non è necessario (anche se è possibile) eseguire il controllo in questo modo:

<?
  $bit = True;

  if($bit == "True"){
     // $bit è vero 
     echo " il valore è vero!";
  }
?>

Basta scrivere:

<?
  $bit = True;

  if($bit){
     // $bit è vero 
     echo " il valore è vero!";
  }
?>

L'interprete riconosce il tipo di dato e controlla se è vero. Nei prossimi capitoli verranno approfondite le caratteristiche dell'istruzione if.

215.3.3   double

Come è stato più volte ripetuto, il PHP non necessita della definizione dei tipi di dati che si vanno a utilizzare ma inizializza il tipo di variabile in base al primo valore a essa associato. I «numeri a virgola mobile» in PHP contengono i tipi conosciuti in altri linguaggi come: floats, doubles, real. È possibile inizializzare una variabile di tipo double assegnandole valori formattati in uno dei seguenti modi:

<?
   $a = 1.234; 
   $a = 1.2e3; 
   $a = 7E-10;
?>

Anche per questo tipo, come per gli interi, la dimensione massima dipende dall'architettura dell'elaboratore su cui viene eseguito lo script.

215.3.4   string

Una stringa è un insieme di caratteri. In PHP non ci sono limiti particolari di lunghezza per i dati di tipo string.

Ci sono più modi di delimitare una stringa. Ecco i due più comuni:

0  <?
1  // single quoted string
2  $nome = 'Gianluca Giusti';
3  
4  // double queoted string
5  $nome = "Gianluca Giusti";
6
7  /* In entrambi i casi $nome viene inizializzata
8     come stringa dall'interprete PHP */
9  ?>

L'interprete PHP riconosce come carattere di escape il \ (barra obliqua inversa). (4)

Di seguito riportiamo i caratteri più comuni, una tabella completa è contenuta nel manuale ufficiale.

Tabella 215.2. Alcuni caratteri di escape per le stringhe PHP.

Carattere Significato
\t carattere tabulazione
\n carattere di fine riga
\\ \ barra obliqua inversa
\" " doppio apice
\$ $ dollaro

Ecco alcuni esempi di come gestire le stringhe.

0  <?
1  // Valorizzo una variabile che servirà in seguito.
2  $email = " brdp @ urcanet.it ";
3
4  // Stringa semplice:
5  $stringa = "Ecco. Questa è una stringa";
6
7  // Ad essa si possono concatenare altre stringhe alla fine
8  $stringa = $stringa." con dell'altro testo aggiunto";
9
10 // che equivale a scrivere
11 $stringa .= " con dell'altro testo aggiunto";
12
13 // Oppure all'inizio
14 $stringa = "altro testo ancora ".$stringa;
15
16 // Adesso si prende la prima lettera della stringa
17 $prima = $stringa{0};
18
19 // Concatenazione multipla
20 $stringa = $prima." - ".$stringa." <br><br> il mio email: ".$email;
21
22 /* Test sui caratteri di escape. All'interno della stringa posso
23    visualizzare il valore di una variabile ma per visualizzarne
24    il nome devo "inibire" il carattere speciale $. Lo faccio con 
25    l'uso della barra obliqua inversa. Ecco come: */
26 $stringa = "Questo il valore di \$email: $email";
27
28 // c'è differenza con:
29 $stringa = "Questo il valore di $email: $email";
30 ?>

L'esempio precedente non è completo. Per poter osservare i risultati delle varie operazioni a schermo è necessario modificare lo script. Questo semplice, ultimo passo è lasciato al lettore come esercizio.

Il PHP fornisce un gran numero di funzioni dedicate alla gestione delle stringhe; uno dei punti di forza di questo linguaggio sta proprio nella semplicità con cui queste possono essere manipolate. Risulta inutile dilungarsi nella trattazione delle singole funzioni, esse verranno descritte negli esempi in cui saranno impiegate. Un elenco completo e dettagliato è contenuto nel manuale ufficiale alla sezione «String functions».

215.3.5   array

Gli array possono essere creati tramite il costrutto array() oppure tramite la valorizzazione degli elementi.

A differenza dei classici linguaggi di programmazione, il PHP permette di indicizzare gli array non solo mediante interi non negativi, ma anche tramite stringhe. Per chi conosce il Perl il concetto è molto simile a quello degli array associativi.

Di seguito la sintassi per creare un array tramite il costrutto array().

0  <?
1  array( [chiave =>] valore
2         , ...
3       )
4  // la chiave può essere un intero non negativo o una stringa 
5  // il valore può essere qualunque
6  ?>

La chiave è contenuta tra le parentesi quadre perchè può essere omessa, se non viene specificata viene incrementato il valore intero. La sintassi di associazione è molto semplice ed intuitiva, per le chiavi intere positive: chiave => valore, mentre per le chiavi di tipo stringa vanno aggiunte le doppie virgolette "chiave" => valore.

Per visualizzare il contenuto dell'array è possibile utilizzare la semplice istruzione print_r($array). Negli esempi seguenti si vedrà come questa funzione visualizza l'array.

Ecco alcuni esempi.

0  <?
1   $a = array( "a", "b", 44, "d", "e");
2   print_r($a);
3  ?>

L'istruzione print_r($a) visualizzerà sullo schermo la struttura e il contenuto dell'array nel seguente modo:

 
 Array ( [0] => a [1] => b [2] => 44 [3] => d [4] => e )

L'indice dei valori è stato incrementato automaticamente. È bene tenere sempre presente che le chiavi degli array partono da 0 e non da 1.

C'è la possibilità di specificare solo alcune chiavi e lasciare la gestione degli indici omessi all'interprete.

0  <?
1   $a = array( "a", "b", "c", "d",  8=>"e",  4=>"f", "g", 3=>"h");
2   print_r($a);
3  ?>

Questo il risultato dello script precedente:

 Array ( [0] => a [1] => b [2] => c [3] => h [8] => e [4] => f [9] => g )

A prima vista il risultato può sembrare errato, ma non è così. L'interprete incrementa automaticamente gli indici omessi dei primi quattro valori, ossia da 0 a 3, e mano a mano valorizza l'array. La lettera e va invece inserita nella cella con chiave, specificata, pari a 8 e la f in quella con chiave 4. Per la lettera g non viene specificata nessuna chiave, l'interprete, quindi, riparte automaticamente dall'indice intero più alto incrementandolo di uno e ottiene il valore 9. Rimane da inserire l'ultima lettera h che va, come richiesto, nella cella con chiave pari a 3. Questa operazione sovrascrive la lettera d che già era stata inserita, in automatico, con chiave pari a 3. A questo punto dovrebbero essere chiari i motivi dell'assenza della lettera d e del particolare ordine con cui vengono visualizzati i valori contenuti nell'array.

Un array può essere creato anche senza l'utilizzo del costrutto array(), in questo caso la sintassi ricorda quella dei più comuni linguaggi di programmazione.

Di seguito sono riportati gli esempi precedenti con l'utilizzo del secondo metodo di creazione.

0  <?
1   $a[] = "a";
2   $a[] = "b";
3   $a[] = 44;
4   $a[] = "d";
5   $a[] = "e";
6   print_r($a);
7  ?>

Il secondo esempio può essere tradotto in questo modo:

0  <?
1   $a[] = "a";
2   $a[] = "b"; 
3   $a[] = "c";
4   $a[] = "d";
5   $a[8] = "e";
6   $a[4] = "f";
7   $a[] = "g";
8   $a[3] = "h";
9   print_r($a);
10 ?>

I due procedimenti per la creazione degli array sono equivalenti.

Gli array possono avere chiavi miste, come nell'esempio seguente, in cui alcune sono intere e alcune stringhe.

0  <?
1   $a["rosso"] = "a";
2   $a[] = "c";
3   $a[8] = "e";
4   $a["nero"] = "f";
5   $a[] = "g";
6   print_r($a);
7  ?>

Ecco il risultato:

 Array ( [rosso] => a [0] => c [8] => e [nero] => f [9] => g )

è interessante studiare una possibile applicazione pratica degli array. Nel seguente esempio verrà ripresa la funzione date() già incontrata nella sezione 214.1.

0  <?
1  // valorizzo l'array dei giorni della settimana con il metodo classico.
2   $giorno[0] = "Domenica";
3   $giorno[1] = "Lunedì";
4   $giorno[2] = "Martedì";
5   $giorno[3] = "Mercoledì";
6   $giorno[4] = "Giovedì";
7   $giorno[5] = "Venerdì";
8   $giorno[6] = "Sabato";
9
10  // valorizzo l'array dei mesi dell'anno con il costrutto array()
11   $mese = array(
12                  1 => "Gennaio",
13                  2 => "Febbraio",
14                  3 => "Marzo",
15                  4 => "Aprile",
16                  5 => "Maggio",
17                  6 => "Giugno",
18                  7 => "Luglio",
19                  8 => "Agosto",
20                  9 => "Settembre",
21                  10 => "Ottobre",
22                  11 => "Novembre",
23                  12 => "Dicembre"
24                 );
25  // Prendo il mese in formato numerico da 1 a 12.
26   $numero_mese = date("n");
27
28  /* Prendo il giorno della settimana da 0 (domenica) a 6 (sabato) 
29     questa volta formatto tutto annidando più funzioni. 
30     in PHP è possibile! */
31     $giorno_settimana = $giorno[date("w")];
32
33  // Formatto la data nel modo: Lunedì 19 Novembre 2001
34   $oggi = $giorno_settimana." ".date("d")."-".$mese[$numero_mese]."-".date("Y");
35
36  // Visualizzo la data a schermo concatendandola ad una stringa
37   echo "<br> Oggi è: <b>".$oggi."</b>";
38  ?>

Il risultato di questo script, raggiungibile presso <http://www.urcanet.it/brdp/php_manual/esempi/cap_2/data.php>, è:

 Oggi è: Domenica 18-Novembre-2001

Gli array rappresentano una delle strutture più versatili in PHP, a differenza dei linguaggi classici, infatti, la dimensione non deve essere specificata a priori. Questo permette una dinamicità e una libertà di utilizzo notevole.

Il PHP gestisce anche gli array multidimensionali e gli array annidati.

Non si entrerà nel merito, si darà per scontata la teoria sulla gestione degli array, che è simile per i diversi tipi di linguaggi, mentre si tratterà la sintassi tramite uno script di esempio.

Il seguente è un esempio sull'utilizzo degli array multidimensionali.

0   <html>
1    <head>
2         <title>Semplice Agenda telefonica statica</title>
3   </head>
4   <body>
5                       
6      <?
7        /* 
8           Un semplice esempio di array multidimensionale.
9           Una rubrica telefonica. 
10        */
11
12         $a["nome"][0] = "Gianluca";
13         $a["cognome"][0] = "Giusti";
14         $a["tel"][0] = "06/66666666";
15
16         $a["nome"][1] = "Mirko";
17         $a["cognome"][1] = "Simeoni";
18         $a["tel"][1] = "07/77777777";
19
20         $a["nome"][2] = "Fabio";
21         $a["cognome"][2] = "Ferri";
22         $a["tel"][2] = "08/88888888";
23
24        /* 
25           Adesso elenchiamo la rubrica. Lo faremo senza 
26           utilizzare Nessuna struttura ciclica per non 
27           confondere le idee
28        */
29
30      ?>
31                      
32      <br>
33
34      <table border="1">
35        <tr bgcolor="gray" >
36           <td>ID</td>
37           <td>Nome</td>
38           <td>Cognome</td>
39           <td>Telefono</td>
40        </tr>
41        <tr>
42           <td>0</td>
43           <td><?=$a[nome][0]?></td>
44           <td><?=$a[cognome][0]?></td>
45           <td><?=$a[tel][0]?></td>
46        </tr>
47        <tr>
48           <td>1</td>
49           <td><?=$a[nome][1]?></td>
50           <td><?=$a[cognome][1]?></td>
51           <td><?=$a[tel][1]?></td>
52        </tr>
53        <tr>
54           <td>2</td>
55           <td><?=$a[nome][2]?></td>
56           <td><?=$a[cognome][2]?></td>
57           <td><?=$a[tel][2]?></td>
58        </tr>
59
60      </table>
61      
62   </body>
63</html>

Una volta salvato il codice nella propria directory dei documenti del servizio HTTP si può verificare il risultato. Anche questo esempio è disponibile all'indirizzo: <http://www.urcanet.it/brdp/php_manual/esempi/cap_2/agenda.php>,inoltre, il risultato è riportato in figura 215.1.

Figura 215.1. La rubrica telefonica è stata formattata in una tabella HTML.

figure/brdp_rubrica_telefonica

Inutile dire che questo è solo un'esempio per prendere confidenza con la sintassi PHP relativa agli array e che esistono soluzioni migliori per il salvataggio dei dati. Più avanti nella guida si tratteranno i file e le basi di dati.

Un esercizio molto utile lasciato al lettore è la realizzazione di uno script clone del precedente con l'utilizzo del costrutto array() per la gestione dell'array utilizzato nella rubrica telefonica.

Gli array di array verranno trattati nella sezione dedicata alla «programmazione avanzata in PHP», in quanto richiedono maggiore dimestichezza con il linguaggio.

215.3.6   object

Una classe è una collezione di variabili e di funzioni dette metodi. Una volta definita la classe è possibile istanziare uno o più oggetti della stessa classe. Ognuno di essi è indipendente dagli altri.

Una trattazione approfondita può essere trovata nella sezione «programmazione avanzata in PHP» di questa guida.

215.4   Operatori

Il PHP gestisce numerosi tipi di operatori, di seguito sono elencate le caratteristiche principali dei tipi utilizzati più di frequente. Per una trattazione completa si rimanda il lettore al manuale ufficiale.

Tabella 215.3. Questi alcuni degli operatori gestiti dal PHP.

OPERATORI
aritmetici assegnazione
controllo degli errori logici
incemento e decremento confronto

Verranno analizzati singolarmente gli operatori riportati nella tabella 215.3.

215.4.1   Operatori aritmetici

Nella tabella 215.4 sono riportati gli operatori aritmetici con le rispettive caratteristiche.

Tabella 215.4. Le caratteristiche degli operatori aritmetici.

Esempio Nome Risultato
$a + $b Addizione Somma tra $a e $b
$a - $b Sottrazione Differenza tra $a e $b
$a * $b Moltiplicazione Prodotto tra $a e $b
$a / $b Divisione Quoziente tra $a e $b

Lo schema è stato preso dal manuale ufficiale, è molto chiaro e non ha bisogno di molte spiegazioni. Bisogna tenere ben presente che il tipo della variabile a cui si assegna il risultato dipende dal tipo dei due valori $a e $b.

215.4.2   Operatori di assegnazione

L'operatore fondamentale per l'assegnazione di un valore ad una variabile è =. La sintassi fondamentale è:

0  <?
1   // assegno ad $a il valore intero 123
2   $a = 123;
3
4   // assegno a $b il contenuto di $a
5   $b = $a;
6
7   // assegno una stringa alla variabile $c
8   $c = "questa è una stringa";
9  ?>

L'operatore = può essere utilizzato insieme ad altri operatori elencati nell'esempio:

0  <?
1   // assegno ad $a un valore intero
2   $a = 2;
3
4   // assegno a $b un altro valore intero
5   $b = 5;
6
7   // posso assegnare a $a la somma di $a e $b in questo modo
8   $a = $a + $b;
9
10  // oppure in questo modo
11  $a += $b;
12
13  // stesso discorso per tutti gli operatori aritmetici
14  $a -= $b;
15  $a *= $b;
16  $a /= $b;
17
18  // posso anche assegnare un valore a più variabili
19  $a = $b = 30;
20
21  // o ancora in questo esempio sia $a che $b valgono 6
22  $a = 3;
23  $b = $a += 3; 
24  
25  // per le stringhe. $a varrà "ciao a tutti!!!" 
26  $a = "ciao a";
27  $a .= " tutti!!!";
28
29  // equivale a concatenare la stringa in questo modo
30  $a = "ciao a";
31  $a = $a." tutti!!!";
32 ?>

I commenti inseriti nell'esempio dovrebbero bastare a descrivere la versatilità degli operatori appena trattati.

215.4.3   Operatori di controllo degli errori

Nell'esempio seguente viene gestito un errore dovuto al tentativo di lettura di un file inesistente. Con l'occasione viene utilizzata la funzione PHP file('nome_del_file') che restituisce un array contenente le righe del file passato alla funzione.

0  <?
1   // provo ad aprire un file che non esiste
2    $file_array = file('file_inesistente') or
3       die (" Errore durante l'apertura del file. ");
4
5   /* 
6     il file non esiste, lo script si ferma 
7     mostrando i messaggi di errore
8   */
9  ?>

Se si salva il codice in un file e si richiama tramite il navigatore, si nota che oltre al messaggio di errore inserito nello script viene visualizzato un messaggio introdotto dall'interprete PHP. I messaggi di errore possono contenere informazioni utili ai male intenzionati, è bene, quindi, gestire tali messaggi al meglio. Un esempio è riportato in figura 215.2 dove si nota il percorso su file system dello script di prova.

Figura 215.2. Ecco come appare la pagina contenente l'errore non gestito. Oltre al messaggio di errore da noi inserito viene visualizzato anche un warning dall'interprete PHP.

figure/brdp_errore_non_gestito

Un modo molto semplice per non far visualizzare i messaggi d'errore dell'interprete è premettere il carattere @ alla funzione. Ad esempio: @file('dati.txt').

L'esempio precedente potrebbe essere modificato in questo modo:

0  <?
1   // provo ad aprire un file che non esiste
2    $file_array = @file('file_inesistente') or
3       die (" Errore durante l'apertura del file. ");
4    /*
5      In questo caso il messaggio di errore  dell'interprete
6      PHP è stato silenziato dalla '@' premessa alla funzione file().
7      Verrà quindi mostrato solo il nostro messaggio di errore
8    */
9  ?>

Il costrutto die() non fa altro che terminare l'esecuzione del programma, in caso di errore, mostrando il messaggio contenuto tra le parentesi.

215.4.4   Operatori di incremento e decremento

Come detto, la sintassi PHP ricorda molto quella del C. Gli operatori di pre e post incrementazione sono gestiti come nel linguaggio C.

Nella tabella 215.5 sono riportati i quattro operatori:

Tabella 215.5. Questi gli operatori di incremento e decremento gestiti dal PHP.

Esempio Nome Risultato
$a++ Post-incremento Restituisce $a e poi la incrementa di uno
++$a Pre-incremento Incrementa di uno $a e poi la restituisce
$a-- Post-decremento Restituisce $a e poi la decrementa di uno
--$a Pre-decremento Decrementa di uno $a e poi la restituisce

Nell'esempio seguente vengono utilizzati i quattro operatori:

0  <?
1    $a = 1;  
2    
3    // Operatori di pre-incremento  
4
5    echo "<br>La variabile vale: ".++$a;  
6    echo " e dopo vale: ".$a;
7
8    // Operatori di post-incremento
9
10   echo "<br>La variabile vale: ".$a++;
11   echo " e dopo vale: ".$a;
12
13   // Operatori di pre-decremento
14
15   echo "<br>La variabile vale: ".--$a;
16   echo " e dopo vale: ".$a;
17
18   // Operatori di post-decremento
19
20   echo "<br> La variabile vale: ".$a--;
21   echo " e dopo vale: ".$a;
22
23 ?>

Se si prova a salvare l'esempio in un file nella directory del servizio HTTP, una volta richiamato mediante il navigatore, il risultato sarà di questo tipo:

  La variabile vale: 2 e dopo vale: 2
  La variabile vale: 2 e dopo vale: 3
  La variabile vale: 2 e dopo vale: 2
  La variabile vale: 2 e dopo vale: 1

Ragionando passo passo si capisce il lavoro dell'interprete e di conseguenza il risultato ottenuto. La variabile inizialmente vale 1. Nella riga 5 viene incrementata, prima di essere visualizzata, tramite l'operatore ++$a. Nella riga 6 viene mostrato il valore di $a senza eseguire alcuna operazione. Da queste prime due righe di codice si ottiene la riga:

  La variabile vale: 2 e dopo vale: 2

Nella riga 10, invece, viene utilizzato l'operatore $a++ che prima visualizza il contenuto della variabile e poi lo incrementa. Infatti la riga 11 restituisce un valore di $a pari a 3. Il risultato è evidente nella seconda riga del file HTML generato dallo script di prova.

Stessa procedura per gli operatori di pre e post decremento, fino a ritornare al valore iniziale della variabile.

215.4.5   Operatori logici

Gli operatori logici gestiti dal PHP sono riportati nella tabella 215.6.

Tabella 215.6. Questi gli operatori logici gestiti dal PHP.

Esempio Nome Risultato
$a and $b AND vera se $a e $b sono vere
$a or $b OR vera se $a o $b è vera
$a Xor $b XOR vera se $a o $b è vera ma non entrambe
!$a NOT Negazione. Vera se $a non è vera
$a && $b AND Simile a and ma con precedenza diversa
$a || $b OR Simile a or ma con precedenza diversa

Le precedenze degli operatori sono riportate nel manuale ufficiale.

In questo momento è inutile dilungarsi in esempi, gli operatori logici verranno approfonditi in seguito. In particolare verranno trattati con l'introduzione dell'istruzione if.

215.4.6   Operatori di confronto

Il PHP gestisce tutti gli operatori di confronto riportati nella tabella 215.7.

Tabella 215.7. Gli operatori di confronto gestiti dal PHP.

Esempio Nome Risultato
$a == $b Uguale vera se $a è uguale a $b
$a === $b Identico vera se $a è uguale a $b e sono dello stesso tipo
$a != $b Diverso vera se $a è diverso da $b
$a <> $b Diverso vera se $a è diverso da $b
$a !== $b Non Identico vera se $a non è uguale a $b o non sono dello stesso tipo
$a < $b Minore vera se $a è minore di $b
$a > $b Maggiore vera se $a è maggiore di $b
$a <= $b Minore o uguale vera se $a è minore o uguale a $b
$a >= $b Maggiore o uguale vera se $a è maggiore o uguale a $b

Esempi pratici sugli operatori di confronto verranno trattati in seguito, nella guida, con l'introduzione delle «strutture di controllo».

215.5   Strutture di controllo

Nella tabella 215.8 sono riportate le strutture di controllo che verranno trattate in dettaglio nelle pagine seguenti.

Tabella 215.8. Le strutture di controllo.

Strutture di controllo
if while break
else do..while include()
elseif for
switch foreach

le strutture di controllo sono state raggruppate per tipologia e ordinate secondo la difficoltà. Di seguito verranno trattati prima i costrutti più semplici e poi quelli più complessi.

Nella prima colonna sono raccolte le strutture tramite le quali si è in grado di eseguire determinate istruzioni al verificarsi di particolari condizioni.

Nella seconda colonna sono raccolte le strutture mediante cui è possibile realizzare e gestire delle operazioni cicliche, fino a quando una particolare condizione viene soddisfatta e interrompe il ciclo.

In questo ultimo caso è importante tenere sempre presente la condizione di STOP. Questo per evitare dei cicli infiniti che possono bloccare il funzionamento del programma.

Inoltre negli esempi che seguono verranno utilizzati gli operatori precedentemente introdotti.

215.5.1   if

Il costrutto if è molto importante e utilizzato in tutti i linguaggi di programmazione. La sintassi è la seguente: 

 if(condizione) 
    singola istruzione

Utilizzato in questo modo, solamente un'istruzione è condizionata dall'esito della condizione contenuta nel costrutto if. Ecco un esempio:

0 <?
1   $a = 3;
2   $b = 5;
3
4   if($a < $b)  // uso un operatore di confronto
5      echo "Condizionato da if. Solo se \$a è minore di \$b.";
6
7      echo "<br>Questo, invece, viene scritto comunque!!!";
8
9 ?>

Se si ha bisogno di condizionare una o più istruzioni la sintassi da utilizzare è la seguente:

 if(condizione){ 
    istruzione 1
    istruzione 2
    .
    .
    .
    istruzione n
 }

Riprendendo l'esempio precedente si può scrivere:

0  <?
1    $a = 3;
2    $b = 5;
3
4    if($a < $b){  
5       echo "Istruzione 1.";
6       echo "Istruzione 2.";
7       echo "Istruzione 3.";
8    }
9
10   echo "<br>Questo, invece, viene scritto comunque!!!";
11
12 ?>

La differenza è semplice e lampante. Il blocco delle istruzioni condizionate va contenuto tra le parentesi { }.

215.5.2   else

Nell'ultimo esempio viene gestito un solo evento. Se si volesse gestire anche l'evento $a >= $b si potrebbe aggiungere, in modo poco elegante e funzionale, un altro if($a >= $b){ istruzioni }. Tuttavia la soluzione più corretta è sicuramente l'utilizzo della struttura else

La sintassi del costrutto else è la seguente:

 if(condizione){
 
    istruzione 1
    istruzione 2
    .
    .
    .
    istruzione n

 }else{

    istruzione 1
    istruzione 2
    .
    .
    .
    istruzione m

 }

Di seguito sono riportati alcuni esempi per chiarirne l'utilizzo e per prendere confidenza con gli operatori precedentemente trattati.

0  <?
1         
2     if(!$a){  // $a è falso.   
3       $a = "ok";
4     }else{
5       $a = "ko";
6     }
7
8     // a questo punto $a vale "ok"
9
10    if($a == "ok"){
11      echo "Sono entrato nell'if e \$a vale: ".$a;
12      echo "<br> Adesso cambiamo il contenuto di \$a";
13      $a = 17;
14    }else{
15      echo "\$a non vale \"ok\" e quindi mi trovo nell'else. \$a: ".$a;
16      echo "<br> anche in questo caso setto \$a uguale a 17 ma in modo diverso.";
17      $a = 16; 
18      $a += 1;
19    }
20
21    // adesso scrivo il tipo e il valore di $a
22
23    if(is_integer($a)){
24      echo "<br> \$a è un INTERO e vale: ".$a;
25    }else{
26      echo "<br> \$a NON è un intero e vale: ".$a; 
27    }
28
29 ?>

Lo script, così come nell'esempio, restituisce un risultato simile al seguente:

  Sono entrato nell'if e $a vale: ok
  Adesso cambiamo il contenuto di $a
  $a è un INTERO e vale: 17

Per comprendere al meglio il flusso del programma e delle strutture in esso contenute, si può inserire nella riga 1 la valorizzazione di $a, ad esempio: 

1     $a = "qualche valore";

Così facendo l'esito del primo if cambia e di conseguenza tutto il resto dello script.

Con l'occasione si è utilizzata una nuova funzione, is_integer(), che restituisce un valore booleano vero se la variabile ad essa fornita è di tipo intero, falso se la variabile non è intera.

Esistono altre funzioni simili per verificare il tipo delle variabili, tra cui: is_array(), is_double(), is_string(). Il funzionamento è analogo a quello di is_integer(). Ovviamente esistono altre funzioni di questo tipo e sono raccolte nella sezione «Funzioni di Variabili» del manuale ufficiale del PHP.

215.5.3   elseif

Si supponga di dover gestire il confronto tra due variabili $a e $b di tipo intero. I possibili risultati del confronto sono tre:

Utilizzando le strutture viste fino ad ora, non si è in grado di risolvere il problema. Una soluzione poco elegante, e sicuramente non ottimale, è eseguire tre if in cascata.

Per risolvere problemi di questo tipo il PHP mette a disposizione la struttura elseif. La sintassi è analoga a quella di else.

 if(condizione){
 
    istruzione 1
    istruzione 2
    .
    .
    .
    istruzione n

 }elseif(condizione){

    istruzione 1
    istruzione 2
    .
    .
    .
    istruzione m

 }else{
 
    istruzione 1
    istruzione 2
    .
    .
    .
    istruzione k

 }

Ecco come applicare la sintassi all'esempio precedentemente descritto: 

0  <?
1    $a = 3;  // valorizzo la variabile $a a mio piacere
2    $b = 6;  // valorizzo la variabile $b a mio piacere
3
4    // adesso eseguo il confronto con un unica istruzione elseif
5
6    if ($a > $b) {
7      echo " \$a è maggiore di \$b ";
8    } elseif ($a == $b) {
9      echo " \$a è uguale a \$b ";
10   } else {
11     echo " \$a è minore di \$b ";
12   }
13
14 ?>

Dunque in questo modo si è in grado di gestire più condizioni. Il flusso è molto semplice e intuitivo. Se una delle due condizioni è soddisfatta l'interprete esegue le istruzioni ad essa associate ed esce dal blocco elseif. Se è presente un else finale e nessuna condizione è stata soddisfatta, l'interprete ne esegue le istruzioni e lascia il blocco elseif.

Va precisato che viene eseguito al massimo un blocco di istruzioni. Se più condizioni sono soddisfatte, solo le istruzioni associate alla prima condizione vera vengono eseguite, le altre vengono saltate.

Si può inserire più di un elseif(condizione) all'interno della struttura. Vediamo come, modificando l'esempio precedente.

0  <?
1    $a = 3;  // valorizzo la variabile $a a mio piacere
2    $b = 6;  // valorizzo la variabile $b a mio piacere
3
4    // adesso eseguo il confronto con un unica istruziione elseif
5
6    if ($a > $b) {
7      echo " \$a è maggiore di \$b ";
8    } elseif ($a === $b) {
9      echo "\$a è identica a \$b";
10   } elseif ($a == $b) {
11     echo " \$a è uguale a \$b ";
12   } else {
13     echo " \$a è minore di \$b ";
14   }
15
16 ?>

Per verificare la correttezza e capire il diverso funzionamento, si provi ad assegnare alla variabile $b i seguenti valori:

Infine si modifichino le righe interessate allo script di esempio nel seguente modo:

8    } elseif ($a == $b) {
9      echo "\$a è uguale a \$b";
10   } elseif ($a === $b) {
11     echo " \$a è identica a \$b ";

In questo modo la voce $a è identica a $b non viene mai visualizzata. Al lettore il semplice compito di scoprirne il motivo. (5)

215.5.4   switch

Spesso ci si trova a dover confrontare il contenuto di una variabile con più valori, in questi casi è preferibile utilizzare la struttura switch al posto di elseif. Un esempio renderà più chiaro il concetto.

Si supponga di dover gestire un menu. In base al valore di una variabile vengono eseguite una o più operazioni. Nell'esempio la variabile $scelta è valorizzata nella riga 2. Per provare il funzionamento del programma basterà cambiare il valore a questa variabile.

0  <?
1    // valorizzo la variabile $scelta
2    $scelta = 0;
3
4    // con switch gestisco i confronti e le operazioni. 
5
6    switch ($scelta) {
7      case 0:
8            echo "<br> lancio l'istruzione associata al valore 0 ";
9            break;  // esce da switch
10     case 1:
11           echo "<br> lancio l'istruzione associata al valore 1 ";
12           break; // esce da switch
13     case 2:
14           echo "<br> lancio l'istruzione associata al valore 2 ";
15           break;  // esce da switch
16     default:
17           echo "<br> NESSUNA OPERAZIONE ASSOCIATA alla scelta";
18
19   }
20
21 ?>

Nella struttura switch a differenza di elseif, l'interprete esegue le istruzioni successive al case soddisfatto. Questo è il motivo per cui si utilizza il comando break. Più avanti si tratterà questo costrutto, per il momento basta sapere che serve ad abbandonare la struttura di controllo.

L'esempio precedente genera un risultato di questo tipo:

  lancio l'istruzione associata al valore 0

Se non ci fossero i break in ogni blocco di istruzione il risultato sarebbe:

  lancio l'istruzione associata al valore 0
  lancio l'istruzione associata al valore 1
  lancio l'istruzione associata al valore 2
  NESSUNA OPERAZIONE ASSOCIATA alla scelta

Se il funzionamento di switch non risulta ancora chiaro, si provi, dopo aver tolto le istruzioni break, ad assegnare alla variabile $scelta i valori: 0,1 e 2, verificandone i singoli risultati.

Nel caso di più uguaglianze la differenza tra switch e elseif è minima, in questi casi, l'utilizzo di switch risulta più elegante e leggibile di elseif. Di seguito viene riportato l'esempio precedente riscritto utilizzando la struttura elseif.

0  <?
1    // valorizzo la variabile $scelta
2    $scelta = 0;
3
4    // adesso utilizzo elseif per gestire le operazioni
5
6    if($scelta == 0) {
7       echo "<br> lancio l'istruzione associata al valore 0 ";
8    }elseif($scelta == 1){
9       echo "<br> lancio l'istruzione associata al valore 1 ";
10   }elseif($scelta == 2){
11      echo "<br> lancio l'istruzione associata al valore 2 ";
12   }else{
13      echo "<br> NESSUNA OPERAZIONE ASSOCIATA alla scelta";
14   }
15
16 ?>

215.5.5   while

Il while è la struttura di gestione dei cicli più semplice del PHP. La traduzione in italiano è: "mentre".

La sintassi è la seguente:

 while(condizione){ 
    istruzione 1
    istruzione 2
    .
    .
    .
    istruzione n
 }

Cioè: «MENTRE la condizione è vera esegui le istruzioni».

Il seguente esempio può aiutare a chiarire le idee.

0  <?   
1    $i=1;
2    while ($i <= 6){    // mentre $i è minore o uguale a 7 
3       echo "<br> \$i adesso vale: ".$i;  
4       $i++;   
5    }
6  ?>

Dunque, in questo caso la condizione di stop, che fa fermare il ciclo, è $i > 6. Ovvero $i <= 6 è falsa.

Il risultato è il seguente:

  $i adesso vale: 1
  $i adesso vale: 2
  $i adesso vale: 3
  $i adesso vale: 4
  $i adesso vale: 5
  $i adesso vale: 6

Tramite un semplice ciclo PHP si può generare una pagina HTML come quella riportata in figura 215.3

Figura 215.3. Questo è stato generato dal ciclo while.

figure/brdp_ciclo_while

Semplicemente è stato eseguito il seguente codice:

0  <html>
1   <head>
2      <title>Ciclo while</title>
3   </head>
4   <body>
5
6      <br> Un ciclo WHILE<br><hr>
7               
8   <?  
9        $i=1;
10        while ($i <= 6){
11  ?>
12
13           <br> <font size="<?=$i?>">Questo è un font con size = <?=$i?></font>
14
15  <?
16           $i++;         
17       }
18  ?>  
19
20
21   </body>
22 </html>

Dal menu {visualizza} del navigatore, l'opzione {sorgente pagina}, mostra il seguente codice:

0  <html>
1    <head>
2      <title>Ciclo while</title>
3    </head>
4    <body>
5      <br> Un ciclo WHILE<br><hr>
6
7      <br> <font size="1">Questo è un font con size = 1</font>
8      <br> <font size="2">Questo è un font con size = 2</font>
9      <br> <font size="3">Questo è un font con size = 3</font>
10     <br> <font size="4">Questo è un font con size = 4</font>
11     <br> <font size="5">Questo è un font con size = 5</font>
12     <br> <font size="6">Questo è un font con size = 6</font>
13
14   </body>
15 </html>

Le righe dalla 7 alla 12 sono state generate dall'interprete con l'esecuzione del ciclo while dell'esempio.

215.5.6   do..while

A differenza del while il do..while esegue il controllo sulla condizione dopo l'esecuzione delle istruzioni. Ecco la sintassi:

 do { 
     istruzione 1
     istruzione 2
     .
     .
     .
     istruzione n
 }while(condizione);

Dunque l'interprete esegue le istruzioni e solo dopo controlla la condizione di stop, se è vera riesegue le istruzioni, se è falsa abbandona il ciclo.

Di seguito è riportato un esempio costituito da due cicli, uno utilizza il costrutto do..while, l'altro il while. Le condizioni iniziali e di uscita sono le stesse ma il risultato è diverso. Al lettore il compito di capire tali differenze.

0  <?
1    // Condizione iniziale!
2      $inizio = 0; 
3    
4    // ciclo do..while
5
6    do{
7        echo "<br> ciclo: do..while. \$inizio vale: ".$inizio;
8    }while($inizio > 0);
9  
10   // mentre il ciclo while 
11
12   while($inizio > 0){
13       echo "<br> ciclo: while. \$inizio vale: ".$inizio;
14   }
15 ?>

215.5.7   for

La sintassi del ciclo for può sembrare incomprensibile ad una prima lettura, invece è molto coincisa, versatile e, con un po' di pratica, semplice. Eccola: 

 for(condizione iniziale; condizione stop; variazione parametro){ 
     istruzione 1
     istruzione 2
     .
     .
     .
     istruzione n
 }

Tale sintassi viene applicata nel seguente modo:

 for($i=0; $i<10; $i++){ 
    echo "<br>tutte le istruzioni che desidero";
 }

Il codice dell'esempio può essere letto come: «partendo da $i = 0, mentre $i<10 esegui le istruzioni e incrementa $i di uno ».

Sia le condizioni che la variazione possono essere omesse o incluse tra le istruzioni. Per il momento verrà trattata la sintassi classica. Il modo più semplice e diretto è, come al solito, un esempio ben commentato. 

0  <?
1     // sintassi classica:
2
3     for($i=0; $i<10; $i++){
4        echo "<br> non serve incrementare, lo fa il for";
5        echo "<br> infatti ecco il valore di \$i: ".$i;
6     }
7
8     // se ho una sola istruzione, come con l'if
9
10    for ($i=0; $i<10; $i++)
11        echo "<br> per una sola va bene così. \$i vale: ".$i;
12
13    // oppure se è solo un print
14
15    for($i=0; $i<10; print"<br>".$i,  $i++)
16
17    // Ancora posso incrementare $i tra le istruzioni
18
19    for($i=0; $i<10; ){
20        echo "<br>incrementare \$i altrimenti il ciclo è infinito. \$i=".$i;
21        $i++;
22    }
23
24    // Oppure premetto la condizione iniziale.
25
26    $i=0;
27    for( ; $i<10;  $i++){
28       echo "<br>eccolo : ".$i;
29    }
30
31 ?>

Come detto è possibile omettere anche le condizioni iniziale e di stop. Per fare questo è necessario utilizzare la struttura break che verrà introdotta nelle pagine seguenti. In quell'occasione verranno trattate tali eccezioni.

A questo punto, un ottimo esercizio per il lettore è la traduzione degli esempi visti per le strutture del while e do..while, in script uguali o simili utilizzando le varie derivazioni del costrutto for.

215.5.8   foreach

Va subito notato che il costrutto foreach è stato implementato dalla versione 4.0 in poi e quindi non è gestita dalle versioni precedenti del PHP.

L'uso del foreach è indicato per la gestione degli array e mette a disposizione due sintassi principali:

 foreach($variabile_array as $value){
    ....
    istruzioni
    ....
 }

e:

   
 foreach($variabile_array as $key => $value){
    ...
    istruzioni
    ...
 }

il suo funzionamento, a differenza del semplice for, non è molto intuitivo ed è vincolato all'utilizzo di un array. Si nota immediatamente che la sintassi non richiede l'utilizzo di indici ne di incrementi, infatti il costrutto opererà su tutti gli argomenti dell'array indistintamente. Dunque questo strumento risulta comodo e versatile quando si ha a che fare con array con chiavi particolari o non consecutive (nel caso di chiavi numeriche).

Si supponga di avere un primo array composto da chiavi intere e consecutive simile al seguente:

 <?
   $array_1 = array (1, "a", 5, "c", "ciao");   // con chiavi da 0 a 4
   print_r($array_1);
 ?>

e un secondo composto da chiavi miste e quindi non consecutive come questo:

 <?
  $array_2 = array ( 
      "uno" => 1,          // chiave stringa e valore intero
      "frutta" => "mela",  // chiave stringa e valore stringa
      5 => "cinque",       // chiave intero e valore stringa
      40 => 30             // chiave intero e valore intero
                );      
   print_r($array_2);
 ?>

I risultati dei due script sono semplicemente:

 Array ( [0] => 1 [1] => a [2] => 5 [3] => c [4] => ciao ) 
 Array ( [uno] => 1 [frutta] => mela [5] => cinque [40] => 30 )

Si supponga ora di non conoscere le chiavi del secondo array perchè assegnate dinamicamente da un codice precedente. In questo caso non si sarebbe in grado di operare sull'array con le strutture cicliche classiche perchè non c'è nessuna relazione tra le chiavi. Mentre nel primo la relazione tra le chiavi è semplice, sono interi successivi a partire da 0. In queste situazioni la struttura foreach è tanto indispensabile quanto semplice ed immediata da utilizzare.

L'esempio potrebbe continuare con la necessità di separare i valori interi da quelli non interi, contenuti in $array_2. Di seguito viene risolto il problema con l'utilizzo del costrutto foreach e della prima sintassi.

0  <?
1    foreach ($array_2 as $val) {
2      echo "<br>\$val = ".$val;
3      if(is_integer($val)){
4         echo " ------&gt; ed è un intero...";
5         // possono seguire istruzioni per trattare i dati interi
6      }else{
7         echo " ------&gt; ma non è un intero...";
8         // possono seguire istruzioni per trattare i dati NON interi
9      }
10   }
11 ?>

foreach in italiano può essere tradotto come per ogni, dunque la sintassi è ora più chiara: per ogni valore dell'array $array_2 preso come $val esegui le istruzioni associate.

Il costrutto ad ogni ciclo valorizza la variabile $val con un elemento dell'array. Ripete l'operazione per tutti gli elementi indipendentemente dalle chiavi ad essi associati.

Nell'esempio le cose sono state complicate con l'annidamento di un if che verifica ad ogni ciclo il tipo di dato estratto dall'array, il risultato è il seguente:

 $val = 1 ------> ed è un intero...
 $val = mela ------> ma non è un intero...
 $val = cinque ------> ma non è un intero...
 $val = 30 ------> ed è un intero...

A questo punto è semplice dedurre il funzionamento della seconda sintassi, infatti, il foreach può estrarre sia la chiave che il valore degli elementi contenuti nell'array. Complicando ulteriormente lo script precedente si può verificare il funzionamento della seconda sintassi.

0  <?
1     foreach ($array_2 as $chiave => $valore) {
2        echo "<br>\$val = ".$valore;
3        if(is_integer($valore)){
4           echo " ------&gt; ed è un intero...";
5           echo " ------&gt; questa la sua chiave: ".$chiave;
6           // possono seguire istruzioni per trattare i dati interi
7        }else{
8           echo " ------&gt; ma non è un intero...";
9           echo " ------&gt; questa la sua chiave: ".$chiave;
10          // possono seguire istruzioni per trattare i dati NON interi
11       }
12    }
13 ?>

Sono state aggiunte le righe 5 e 9 che visualizzano il volore delle chiavi ed è stata modificata la sintassi della riga 1 in cui si chiede al foreach di estrarre anche le chiavi degli elementi dell'array oltre al valore e di assegnarli alle variabili $chiave e $valore. Il risultato è il seguente:

 $val = 1 ------> ed è un intero... ------> questa la sua chiave: uno
 $val = mela ------> ma non è un intero... ------> questa la sua chiave: frutta
 $val = cinque ------> ma non è un intero... ------> questa la sua chiave: 5
 $val = 30 ------> ed è un intero... ------> questa la sua chiave: 40

In conclusione il costrutto foreach è una struttura ciclica dedicata alla manipolazione degli array. Ovviamente possono essere gestiti anche array multidimensionale con dei foreach annidati, il lettore può approfondire l'argomento sul manuale ufficiale.

L'esempio trattato è raggiungibile all'indirizzo: <http://www.urcanet.it/brdp/php_manual/esempi/cap_2/foreach.php>

215.5.9   break

Il costrutto break serve ad abbandonare una struttura di controllo, nel dettaglio permette di uscire da: for, foreach, while, do..while e switch, e ammette un parametro numerico opzionale. Tale parametro deve essere un intero che indicherà il "livello" della struttura da abbandonare. Ad esempio, nel caso di due o più strutture annidate, si potrebbe voler uscire da una o più di esse: questo è possibile tramite il parametro.

Con l'occasione verranno approfondite, negli esempi seguenti, le strutture tralasciate in precedenza. 

0  <?
1
2   $i = 0;
3   while (++$i) {   // il while incrementa anche in questo modo
4 
5     if($i == 3){
6
7       echo "<br>Conto fino a ".$i." ed esco solo dal conteggio: ";
8     
9       for ($t = 1; ;$t++) {  // la condizione di stop è tra le istruzioni.
10        if ($t > $i) {
11          break 1;   // esce solo dal for equivale a break senza parametri.
12        }
13        echo " ".$t;
14      }
15
16    }elseif($i == 9){
17
18      echo "<br> Conto fino a ".$i." ed esco dal for e dal while:";
19
20      $t = 1;
21      for (;;) {  // Nessuna condizione è espressa nel costrutto.
22        if ($t > $i) {
23          break 2;  // il parametro è 2 quindi esce dal for e dal while.
24        }
25        echo " ".$t;
26        $t++;
27      }
28
29    }
30
31 }
32
33 echo "<br><br> fine dello script!";
34
35 ?>

Come detto in precedenza, è importante curare l'indentazione del codice. L'ultimo esempio è composto da un ciclo while che include un elseif e due cicli for che, a loro volta, contengono un if ciascuno. Tutto questo susseguirsi di parentesi può creare confusione e rendere il codice illegibile se non si presta attenzione all'indentazione.

Nella maggior parte dei casi, se il codice è ben scritto e ragionato, non si ha bisogno della struttura break. Tuttavia è bene sapere che esiste.

215.5.10   include()

Il PHP permette di includere uno o più file in un punto ben preciso di un altro file. Tali file possono, a loro volta, contenere codice PHP che verrà interpretato se delimitato dagli appositi marcatori.

Si pensi alla gestione di modelli grafici, alla necessità di dichiarare le stesse variabili in più file, all'inclusione di funzioni già pronte e via dicendo. In tutti questi casi è possibile creare un file specifico in cui inserire il codice che va incluso negli script. Ovviamente è possibile includere anche file residenti su macchine diverse dalla nostra. Di seguito vedremo come fare.

Per l'inclusione dei file il PHP offre diverse soluzioni. In questa guida verrà approfondita la funzione include(). Ne esistono altre che sono riportate nel manuale ufficiale.

La sintassi di base è la seguente:

0   <?
1     // inclusione di un file chiamato esterno.html
2
3     include('esterno.html');
4
5   ?>

è preferibile utilizzare le stringhe con double quote perchè meglio gestite e più versatili:

0  <?
1     // oppure con il double quote
2
3     include("esterno.html");
4
5  ?>

Come accennato in precedenza, il file da includere può trovarsi su una macchina diversa dalla nostra. Supponiamo che sia accessibile tramite il protocollo HTTP. La sintassi sarà:

0  <?
1     /* inclusione di un file remoto. 
2        Su una macchina diversa, tramite
3        il protocollo HTTP
4     */
5
6     include("http://www.url_altro_sito.com/esterno.html");
7
8  ?>

Questo modo di operare è del tutto corretto. Tuttavia va tenuto conto dei seguenti fattori:

Alcuni di questi ostacoli possono essere aggirati, altri no. Ad esempio, il primo problema non è risolvibile. Per quanto una connessione sia veloce ed i servizi performanti si aggiunge sempre un intervallo di tempo dovuto alla procedura di richiesta del file. Questo è un parametro molto importante, che va tenuto presente quando si effettua una scelta di questo tipo. Il tempo necessario, inoltre, non è sempre lo stesso ma dipende da svariati fattori, ad esempio il traffico sul sito remoto, il traffico sulla rete, ecc...

Il secondo punto può essere affrontato in vari modi, quello più sbrigativo è sicuramente la gestione dell'errore generato con la mancata inclusione del file. Ecco un modo di procedere:

0  <?
1     /* inclusione di un file remoto. Su una macchina diversa, 
2        tramite il protocollo HTTP.
3        Compresa la gestione dell'errore!!!
4     */
5
6     if( !@include("http://www.url_altro_sito.com/esterno.html") )
7        echo "<br><br> Problemi di visualizzazione! torna a trovarci...";
8     
9  ?>

In questo modo si è reso invisibile l'eventuale messaggio di errore dell'interprete tramite il prefisso @. Per il resto si tratta di un semplice if che verifica il valore restituito dalla funzione include(), se il valore è falso visualizza il messaggio di errore, altrimenti include il file e prosegue.

Se il file remoto è uno script, ad esempio PHP, prima di essere incluso viene interpretato dal servente, quindi viene incluso il risultato dello script generato in remoto e non sull'elaboratore su cui è ospitato il nostro script .

Programmare in PHP --- Copyright © 2001-2002 Gianluca Giusti --  brdp @ urcanet.it

1) Nel caso in cui il servente sia Apache, le variabili HTTP nella pagina phpinfo() vengono raccolte nella sezione «variabili di Apache»

2) Se si segue il percorso degli script proposti dalla guida, il visitatore arriverà da <http://www.urcanet.it/brdp/php_manual/esempi/cap_1/primo.php>

3) I numeri naturali sono il sottoinsieme positivo dei numeri interi.

4) il carattere di escape viene utilizzato per rappresentare caratteri speciali all'interno di una stringa, caratteri che potrebbero creare confusione all'interprete.

5) La condizione di identità include quella di uguaglianza, quindi, se due variabili sono identiche di conseguenza sono anche uguali, mentre non è vero il contrario. Ecco perchè bisogna fare attenzione all'ordine in cui si scrivono le condizioni.

Dovrebbe essere possibile fare riferimento a questa pagina anche con il nome le_basi_del_linguaggio.html

[successivo] [precedente] [inizio] [fine] [indice generale] [violazione GPL] [translators] [docinfo] [indice analitico]