Tutorial PHP

Nozioni varie
Tipi di dati
Scope delle variabili
Costanti
Istruzioni condizionali
Cicli
print ed echo
Funzioni per gestire le stringhe
Formattazione stringhe
Confronto stringhe
Espressioni regolari o pattern
Array
Funzioni personalizzate
Scope delle variabili e inclusione dei file in PHP
Validazione dei dati
Richieste HTTP (GET e POST)
Gestire i Cookie con PHP
Gestire le sessioni in PHP
Gestire delle password con PHP
Funzioni PHP per JSON
Generare file JSON da Database
Funzioni PHP per XML
Generare file XML da DB
Gestire file con PHP
Manipolare le immagini con PHP e GD
Realizzare un sistema CAPTCHA con PHP
Inviare email con PHP

Nozioni varie
Una variabile si crea seguendo la sintassi: $nomeVariabile;
Il simbolo . si usa per concatenare le stringhe;
Per stampare un dato si usa la parola chiave echo "fraseDaStampare" | $nomeVariabile
Il confronto segue il seguente ordine: maiuscolo > minuscolo > cifre

Tipi di dati
PHP NON e' un linguaggio tipizzato, tant'e' che possiamo assegnare alla stessa variabile piu tipi di dato all'interno della stessa
esecuzione di codice.
Con la stessa invocazione si possono richiamare i seguenti tipi di dato:

booleani;
interi;
float o double;
stringhe;
array;
oggetti;

Scope delle variabili

Lo scope di una variabile e' l'area in cui essa e' visibile durante l'esecuzione dello script, esso puo essere di 3 tipi:

1. locale (variaible dichiarata all'interno di una funzione)

2. globale (variabile dichiarata al di fuori di una funzione. Le variabili globali non sono accessibili all'interno di una funzione a meno
che non usiamo la keyword global: global $nomeVariabileGlobaleDaRichiamare dentro la funzione per bypassare la limitazione)
3. statico (variabile deve essere dichiarata nel seguente modo: static $nomeVariabile e vengono usate nel caso in cui non
volessimo cancellare il valore assunto dalla variabile locale)

Esistono anche le variabili superglobali che sono disponibili sempre in tutti gli scope

$GLOBALS => contiene nome variabili definite con la keyword global

$_SERVER => contiene info relative al server e allo script
$_GET => contiene parametri passati tramite URL
$_POST => contiene parametri passati come POST allo script
$_FILES => contiene info relative ai file uploadati
 $_COOKIE => contiene cookie
$_SESSION => contiene info relative alla sessione corrente
$_REQUEST => contiene tutti i parametri contenuti anche in GET, POST, COOKIE
$_ENV => contiene tutti i parametri passati all'ambiente

Abbiamo anche le variabili dinamiche utili nel caso in cui volessimo accedere a determinate variabili delle quali non conosciamo il
nome ma le sue info sono salvate all'interno di un'altra variabile. In questo caso e' possibile utilizzare il contenuto di una variabile come
variabile stessa:
$italiano = "Ciao";
$lingua = "italiano";
echo $$lingua.",Simone";

Ecco il risultato:

Le costanti
Le costanti si definiscono attraverso il costrutto define ("nomeVariabile", "valoreAssociato");.
Il costrutto defined ("nomeCostante"), restituisce 1 se la costante esiste, altrimenti non stampa nulla.
Per recuperare tutte le costanti utilizzate all'intenro dell'esecuzione si usa la funzione: get_defined_constants().
Vi sono inoltre delle costanti predefinite come:

__FILE__ => contiene path del file su cui ci troviamo

__DIR__ => contiene percorso directory in cui e' contenuto file correte
__FUNCTION__ => contiene nome funzione che stiamo utilizzando
__LINE__ => contiene numero riga corrente
__CLASS__ => contiene nome classe corrente
__METHOD__ => contiene nome metodo corrente
__NAMESPACE__ => contiene nome namespace corrente
__TRAIT__ => contiene nome trait corrente

Istruzioni condizionali
If

Sintassi:
if (condizione) {blocco istruzioni};

Switch

Sintassi:
$colore = rosso;
switch($colore){
case "blu":
echo "Il colore selezionato e' blu";
break;
case "rosso":
echo "Il colore selezionato e' rosso";
break;
default:
echo "nessun colore corrisponde alla tua selezione";
break;
}

Operatore Ternario

Rappresenta un'alternativa al costrutto if/else.

Sintassi:
($altezza >= 180) ? "alto" : "normale";
Bisogna leggerla cosi: Se il valore della variabile $altezza e' maggiore/uguale a 180 allora stampo "alto", altrimenti stampo "normale"

I cicli
for
Sintassi:
for (condizioneDiPartenza; condizioneDiArrivo; Aggiornamento){
blocco codice;
}Il ciclo for funziona come in Java e ha anche la stessa costruzione
NOTA: la stessa cosa vale per i cicli while e do...while

foreach

Si usa nel caso in cui volessimo effettuare delle operazioni per OGNI elemento del nostro ARRAY
Sintassi:
foreach($nomeArray as $nomeDaAssegnareAdOgniSingoloElementoDell'Array){
blocco codice;
} es: $array_monodimensionale = array(1,2,3,4,5);
$somma = 0;
foreach($array_monodimensionale as $valore){
$somma += $valore;
}
echo "La somma degli elementi dell'array e': ".$somma; =>

print ed echo
echo
Per stampare un valore di norma si usa il costrutto echo, ma, in alternativa, possiamo usare la sua forma abbreviata nel caso in cui
bisogna stampare un nome all'interno di una pagina HTML Sintassi:

print

E' un altro costrutto utilizzato per stampare stringhe in output.

La differenza tra print ed echo e' che print ha un valore di ritorno bolleano, mentre il costrutto echo non ha valore di ritorno.
Un'altra differenza e' che print NON permette di separare con la virgola diverse stringhe da stampare, ma consente unicamente di
concatenarle tra di loro

Funzioni per gestire le stringhe

Verificare lunghezza stringa

Sintassi:
strlen($stringa);

Restituire porzione stringa

Sintassi:
Tale funzione prende in ingresso fino a 3 parametri
substr($nomeVariabile, IndiceInizio, IndiceFine);

Cercare porzione di testo in una stringa

Sintassi:
strpos($nomeVariabile, "sottostringaDaCercare");

Invertire stringa
Sintassi:
strrev($stringa | "stringaDaInvertire");

Sostituire tutte occorrenze stringa

Sintassi:
str_replace("valoreDaSostituire", "ValoreCheRimpiazza", $stringheDoveSostituire, "NumeroOccorrenzeSostituite"
(opzionale));

Suddividere una stringa

Sintassi:
explode('carattereSeparatore', $stringaDaDividere, "NumMaxElementiDaEstrarre"(opzionale));

Modificare maiuscole/minuscole

In PHP ci sono un set di funzioni per modificare le maiuscole/minuscole a seconda dell'esigenza:

 strtoupper()
strtolower()
lcfirst()
ucfirst()
ucwords()

Rimuovere spazi all'inizio o alla fine di una stringa

Sintassi:
trim();
ltrim();
rtrim();

Formattazione delle stringhe

La concatenazione eseguita con $stringa.$stringa2 risulta scomoda nel caso di frasi concatenate poiche' non inserise in automatico lo
spazio a meno che non venga inserito manualmente dal programmatore Per risolvere questo problema, si puo usare la funzione sprintf().
Tale funzione e' utile per generare stringhe formattate in maniera piu semplice e scrivere cosi codice piu leggibile.
es:
$nome = "Simone";
$eta = 29;
$citta = "Forli";
$provincia = "Cesena";
$regione = "Emilia Romagna";
$formato = "%s ha $d anni ed e abita a $s in provincia di %s, nella regione %s";
$stringa = sprintf($formato, $nome, $eta, $citta, $provincia, $regione);

La funzione stampera':

La funzione sprintf() ci consente di effettuare delle sostituzioni all'interno di una stringa nei punti in cui inseriamo dei placeholder
(segnaposto) delimitati dal carattere %.
La funzione prende in ingresso almeno 2 parametri.
I placeholder cambiano dicitura in base al tipo di dato da inserire:

%% => segno percentuale

%b => numero binario
%d => decimale con segno
%u => decimale senza segno
%s => stringa

Se invece volessimo stampare direttamnete a schermo la stringa formattata senza dover specificare successivamente il comando echo,
possiamo ricorrere alla funzione printf() che funziona in modo identico a sprintf().

Confronto tra stringhe

Per confrontare le stringhe si usa il classico operatore == e rispetta i seguenti ordini di grandezza:

1. ordine alfabetico
2. caratteri maiuscoli
3. caratteri minuscoli
4. cifre

Il PHP inoltre fornisce due funzioni specifiche per il confronto di stringhe.

La funzione strcmp() consente di effettuare gli stessi controlli, ma prende in ingresso due parametri che rappresentano le due stringhe e
restituiscono un valore intero che puo essere:

< 0 se la prima stringa e' minore della seconda

= 0 se le stringhe coincidono
>0 se la prima stringa e' maggiore della seconda

Nel caso in cui invece abbiamo bisogno di effettuare confronti NON sensibili alle maiuscole, utilizziamo la funzione strcasecmp()

Gestire le date
Per gestire il tempo PHP mette a disposizione delle funzioni.
La funzione time() restituisce il timestamp attuale
Se volessimo recuperare il timestamp di una qualsiasi data, utilizziamo la funzione strtotime() che prende in ingresso una stringa che
contiene il riferimento temporale che si vuole convertire.
es:
echo strtotime("2015-01-01");
Questa funzione ci permette di passare anche valori molto vicini al linguaggio naturale come:

now
+1 day
+1 week
+1 week 2 days 4 hours 2 seconds
next Thursday

Se volessimo formattare una data, utilizziamo la funzione date() che prende in ingresso due parametri:

$format => formato in cui vogliamo stampare la data

$timestamp => timestamp della data da stampare

es:
$timestamp = strtotime("+1 day");
echo date("d/m/Y H:i:s", $timestamp);

Espressioni regolari e pattern

Un'espressione regolare e' una stringa, definita pattern, che contiene al suo interno una serie di simboli attraverso i quali e' possibile
identificare gruppi di strighe.
Per permettere tale ricerca, bisogna utilizzare la seguente sintassi:

1. / serve per iniziare e terminare il pattern

2. ^ indica che la stringa deve iniziare con il pattern indicato. Senza questo simbolo la stringa viene identificata dal pattern, e quindi
cerca in qualsiasi punto della stringa
3. [a-z0-9_-] indica che i caratteri ammessi sono tutte le lettere minuscole, i numeri da 0 a 9 e i simboli _ e -
4. {3,15} indica che deve essere di lunghezza compresa tra 3 e 15
5. $ indica che la stringa deve terminare con il pattern appena visto, quindi non sono ammessi altri caratteri

Come fa il PHP a verificare la vailidita' della stringa secondo il pattern impostato?

Utilizziamo la funzione preg_match() che prendein ingresso 3 parametri:

pattern
stringa da verificare
array in cui vengono salvati i risultati della ricerca (opzionale)

es:
$username = 'dymissy86';
if (!preg_match('/^[a-z0-9_-]{3,15}$/', $username)) {
echo "Lo username non e' valido";
} else {
echo "Username valido";
}

Stampera':

Sintassi PCRE

Le regole delle espressioni regolari appartengono alla famiglia PCRE.

Vediamo altri meta caratteri che definiscono la sintassi delle regex:

\ => carattere generico escape

^ => delimitatore inizio stringa
$ => delimitatore fine stringa
. => definisce ogni carattere eccetto carattere invio
[ => carattere di inizio definizione classe
] => carattere di fine definizione classe
| =>inizio ramo alternativo
( => inizio subpattern
) => fine subpattern
? => 0 o 1 occorrenza
* => 0 o piu occorrenze
+ => 1 o piu occorrente
{ => inizio intervallo min/max occorrenze
 } => fine intervallo min/max occorrenze
- => indica un range di caratteri all'interno di []
. => indica singolo carattere
\s => un carattere spaziatura
\S => tuto eccetto carattere spaziatura
\d => un carattere numerico
\D => tutto eccetto carattere numerico
\w => una lettera (a-z, A-Z, 0-9, _)
\W => tutto eccetto una lettera
[aeiou] => uno dei caratteri compresi nella parentesi
[^aeiou] => tutto eccetto caratteri compresi nella parentesi
(foo|bar|baz)

Utilizzare espressioni regolari

Abbiamo visto che la funzione preg_match puo salvare i risultati della ricerca in un array.
es:
/^(\d*)-(\d*)$/
La regex e' vera se la stringa e' formata da due serie di numeri separati da un carattere -
Ora supponiamo che dato un numero di telefono, si abbia l'esigenza di separare il prefisso dal numero, possiamo usare la funzione in
questo modo:
$pattern = "/^(\d*)-(\d*)$/";
preg_match($pattern, '340-8652066', $result);
$prefisso = $result[1];
$numero = $result[2];

Il parametro chiamato $result serve per recuperare le info relative al prefisso e al numero.
Questo perche' il terzo parametro conterra' i risultati della ricerca.
La funzione preg_match_all differisce dalla precedenze poiche' restituisce tutte le occorrenze che corrispondono al pattern utilizzato.
es:
Supponiamo di avere una stringa che contiene diversi numeri di telefono che vogliamo salvare in un array $stringa = 'Ufficio:
0452-222222 Cellulare: 300-0000000 Casa: 0775-12312123';
$pattern = '/(\d*)-(\d*)/';
preg_match_all($pattern, $stringa, $result);
$numeri = $result[0];
var_dump($numeri);
var_dump ci restituira':

Con la funzione preg_replace possiamo sostituire le occorrenze di una regex con un'altra stringa.
La funzione prende in ingresso 4 parametri:

1. pattern
2. stringa che verra' sotituita
3. stringa da sostituire
4. limite delle sostituzioni da fare (opzionale)

La funzione preg_replace_callback si occupa di effettuare delle sostituzioni con la differenza che prende in ingresso una funzione di
callback per effettuarle:

1. pattern
2. funzione di callback
3. stringa da sostituire
4. limite delle sostituzioni da effettuare(opzionale)

La funzione di callback prende in ingresso un array che contiene i risultati di ricerca (come nel caso di preg_match).
es:
Supponiamo di voler trasformare una URL di YouTube nel suo codice di embed per mostrarlo all'interno di una pagina. Nel nostro caso
usiamo la funzione preg_replace_callback
$youtubeUrl = '[Link]
$youtubePattern = "/\s*[a-zA-Z\/\/:\.]*youtu([Link]\/watch\?v=|.be\/)([a-zA-Z0-9\-_]+)([a-zA-Z0-9\/\*\-\_\?
\&\;\%\=\.]*)/i";
function youtubeEmbedCallback($matches) {
if (!isset($matches[2])) {
return '';
}
$videoId = $matches[2];
return '< iframe width="560" height="315" src="[Link] . $videoId . '" frameborder="0"
allowfullscreen>< /iframe>';
}
$youtubeEmbed = preg_replace_callback($youtubePattern, "youtubeEmbedCallback", $youtubeUrl);
echo $youtubeEmbed;

Stampera':
'; } $youtubeEmbed = preg_replace_callback($youtubePattern, "youtubeEmbedCallback", $youtubeUrl); echo $youtubeEmbed; ?>

Array
Un'array e' una collezione di elementi identificati da un indice.
Un array puo' essere definito in due modi:
$array = array();
$array = array("banana", "lamponi"); $array = [];
$array = ["banana", "pesca"];
In ogni momento possiamo visualizzare il contenuto di un'array con la funzione print_r()

Array associativo

Possiamo sfruttare gli indici di un array come stringhe anziche' come valore numerico:
es:
$annoDiNascita = [
'Simone' => '1986',
'Gabriele' => '1991',
'Giuseppe' => '1992',
'Renato' => '1988'
];
In questo array ogni elemento e' caratterizzato da una coppia chiave => valore in cui la chiave (index) e' il nome di una persona e il
valore e' il suo anno di nascita.
Supponiamo di voler stampare la data di nascita di uno delgi utenti, alora possiamo accedere al suo valore in questo modo:
echo "L'anno di nascita di Gabriele e' ".$annoDiNascita["Gabriele"];
Usando la funzione print_r() sull'array definito in precedenza, eseguendo il comando print_r($annoDiNascita); otterremo il seguente
output:
'1986', 'Gabriele' => '1991', 'Giuseppe' => '1992', 'Renato' => '1988' ]; print_r($annoDiNascita); ?>
Ovviamente un array puo contenere ulteriori array:
es:
$partecipanti = [
'Simone' => [
'anno' => '1986',
'sesso' => 'M',
'email' => 'test@[Link]'
],
'Gabriele' => [
'anno' => '1991',
'sesso' => 'M',
'email' => 'test2@[Link]'
],
'Josephine' => [
'anno' => '1985',
'sesso' => 'F',
'email' => 'test3@[Link]'
],
];
E per accedere a un dato specifico in questo caso si usa la seguente sintassi:
echo "La mail di Josephine e':.$partecipanti["Josephine"]["email"]; ( [ 'anno' => '1986', 'sesso' => 'M',
'email' => 'test@[Link]' ], 'Gabriele' => [ 'anno' => '1991', 'sesso' => 'M', 'email' =>
'test2@[Link]' ], 'Josephine' => [ 'anno' => '1985', 'sesso' => 'F', 'email' => 'test3@[Link]' ], ];
echo $partecipanti["Josephine"]["email"]; ?> )

Funzioni PHP per gestire gli array

Possiamo contare gli elementi di un array con la funzione count($array)

Possiamo verificare se un determinato valore sia presente all'interno dell'array con la funzione in_array("valore", $array);
Possiamo mescolare gli elementi dell'array con la funzione shuffle($array);
Possiamo invertire l'ordine degli elementi con la funzione array_reverse($array);
Dati due o piu array, possiamo avere un unico array che contiene gli elementi di entrambi, con l'inserimento che avviene in
maniera da aggiungere gli elementi in coda all'array precedente, il tutto grazie alla funzione array_merge($array1,$array2);
Possiamo estrarre solo alcuni elementi con la funzione array_slice($array, offsetDaCuiIniziare,
NumElementiDaEstrarreAPartireDall'Offset);
Possiamo estrarre coppie chiave/valore da un array multidimensionale grazie a due funzioni array_keys($array) e
 array_values($array)

Funzioni personalizzate PHP

Sintassi per creare una semplice funzione:
function somma ($a, $b){
return $a + $b;
}
Una funzione si richiama attraverso il suo nome e la specifica di eventuali parametri presi in input:
echo "La somma di 5 e 4 e': ".somma(5,4);

Scope delle variabili e inclusione dei file

Scope delle variabili

Per scope si intende la visiblita' di una variabile, ovvero la porzione di coice in cui essa e' accessibile.
In PHP abbiamo l'array $GLOBALS che contiene tutte le variabili dichiarate fino a quel momento, comprese le variabili predefinite.
Possiamo quindi utilizzarlo per accedere al valore della variabile.
es:
$a = 10;
function sum($b){
return $GLOBALS['a'] + $b;
}
echo sum(10);
( )

Includere file nel codice

E' possibile inserire contenuto di un file PHP in un altro file PHP con i costruti include e require.
Per includere il file e' sufficiente richiamarlo con il suo path completo:
es:
include "[Link]";
oppure require "[Link]";

Scope delle variabili con include e require

Una variabile definita PRIMA di includere un file e' sempre visibile all'interno di un file incluso.
es:
Supponiamo di creare un file chiamato [Link] con contenuto:
< ?php
$a = $a * 100;
?>
e di avere il nostro codice principale in un file [Link], nella stessa cartella dell'altro file con contenuto:
< ?php
$a = 10;
include "[Link]";
echo $a;
?>
Eseguendo il codice di [Link] verra' stampato il valore 1000 perche' la variabile $a e' visibile all'interno del file incluso.

Evitare inclusioni ripettute dello stesso file

Supponiamo di avere un codice in cui in base a determinate condizioni potrebbe capitare di includere piu volte lo stesso file.
Se nel file incluso vengono definite funzioni o modficate i valori di variabili, sicuramente si possono avere risultati inaspettati.
Per evitar tali situazioni si usano i costrutti include_once e require_once.
Entrambi consentono di includere una sola volta lo stesso file anche se il costrutto venisse richiamato piu volte.
es:
< ?php
$a = 10;
include "[Link]";
include "[Link]";
echo $a;
?>
Il risultato NON sara' 1000 ma 10000 perche' la moltiplicazione viene eseguita due volte. Se invece avessimo usato i costrutti sopra
citati, il risultato continuera' ad essere 1000.

Validazione dei dati in PHP

In PHP, grazie alla funzione filter_var() vi sono due macrotipi di filtri che possiamo utilizzare per validare e/o ripulire dati:

1. validation: verificano che un dato sia o meno valido;

2. sanitization: modificano il dato per renderlo valido;

Validation dei dati

La validazione di un indirizzo email e' probabilmente il caso piu comune:

es:
$emailValida = "test@[Link]";
$emailNonValida = "[Link]";
if (filter_var($emailValida, FILTER_VALIDATE_EMAIL)){
echo "$emailValida valida";
} if (filter_var($emailNonValida, FILTER_VALIDATE_EMAIL)){
echo "$emailNonValida valida";
}
Il primo if stampera' la stringa "email valida; nel secondo caso, dato che abbiamo utilizzato una stringa che contiene una email non
valida, non verra' stampato nulla.
Quindi la funzione filter_van() prende in ingresso 2 parametri:

1. variabile da validare
2. filtro per veficare se il dato e' valido

Vediamo quali sono i filtri a disposizione:

FILTER_VALIDATE_BOOLEAN => restituisce true per i valori "1", "true", "on", "yes"
FILTER_VALIDATE_EMAIL => verifica validita' di una mail
FILTER_VALIDATE_FLOAT => verifica validita' di un float valido
FILTER_VALIDATE_INT => verifica validita' di un intero valido. Possiamo anche verificare che sia compreso in un range
FILTER_VALIDATE_IP => verifica validita' di un IP
FILTER_VALIDATE_REGEXP =>verifica validita' di un'espressione regolare
FILTER_VALIDATE_URL => verifica validita' di un URL

Sanization dei dati

Oltre che validare un dato, possiamo che modificarlo, in modo tale che PHP provi a renderlo valido:
es:
$email1 = "test@[Link]";
$email2 = "(test@[Link])";
$email3 = "[Link]";
function sanitizzaEmail($email) {
$emailSanitizzata = filter_var($email, FILTER_SANITIZE_EMAIL);
$emailValida = filter_var($emailSanitizzata, FILTER_VALIDATE_EMAIL);
echo "Indirizzo email: $email\n";
echo "Indirizzo email sanitizzato: $emailSanitizzata\n";
echo "Email valida: " . ($emailValida ? 'SI' : 'NO') . "\n\n";
}
sanitizzaEmail($email1);
sanitizzaEmail($email2);
sanitizzaEmail($email3);
Risultato:
"); sanitizzaEmail($email2 . "
"); sanitizzaEmail($email3 . "
"); ?>
Anche qui la modifica avviene tramite un apposito filtro. Ecco qui alcuni filtri disponibili:

FILTER_SANITIZE_EMAIL => rimuove tutti i caratteri eccetto lettere, numeri e !#$%&'*+-/?^_{

FILTER_SANITIZE_ENCODED => codifica URL
FILTER_SANITIZE_NUMBER_FLOAT => rimuove tutti i caratteri eccetto numeri e simboli + e -
FILTER_SANITIZE_NUMBER_INT => rimuove tutti i caratteri eccetto simboli + e -
FILTER_SANITIZE_SPECIAL_CHARS => escape HTML dei carateri '"<>&
FILTER_SANITIZE_FULL_SPECIAL_CHARS => equivale alla funzione htmlspecialchars()
FILTER_SANITIZE_STRING => rimuove tutti i tag
FILTER_SANITIZE_STRIPPED => alias del filtro FILTER_SANITIZE_STRING
FILTER_SANITIZE_URL => rimuove tutti i caratteri eccetto numeri e simboli
FILTER_SANITIZE_RAW => non compie operazioni, opzionalmente rimuove o codifica caratteri speciali

Nel caso in cui avessimo bisogno di passare un URL come parametro GET di una richiesta HTTP, abbiamo bisogno di codificarlo cosi
da non creare problemi nell'interpretazione dell'URL.
Per passare come parametro GET un URL su cui fare un redirect abbiamo bisogno di un encoding usando il filtro
FILTER_SANITIZE_ENCODED
es:
$url = "[Link]
echo filter_var($url, FILTER_SANITIZE_ENCODED);
che restituira':

A questo punto potremmo salvare il valore in una variabile da appendere alla stringa del redirect

Richieste HTTP (GET e POST)

Il PHP e' un linguaggio principalmente per il Web e la conseguenza principale di questa caratteristica e' la possibilita' di effettuare
richieste HTTP.
Come funziona una normale richiesta HTTP tra client e server:

1. Il client effettua una richiesta HTTP al server

2. Il server elabora la richiesta e restituisce una risposta
3. La risposta puo essere una pagina HTML, un file JSON, un'immagine o qualsiasi alttro formato

La specifica HTTP definisce 9 tipi di metodi alcuni dei quali non sono supportati da PHP;
I piu diffusi restano sicuramente GET e POST:

GET e' il metodo con cui vengono richieste la maggior parte delle info ad un Web server, tali richieste vengono veicolate tramite
query string
es:
[Link]/pagina-richiesta?id=123&page=3
POST consente di inviare dati ad un server senza mostrarli in query string come nel caso delle form

METODO GET

Metodo consigliato in quelle richieste in cui e' utile salvare nell'URL i parametri richiesti. Un caso d'uso tipico e' una query di ricerca

Come possiamo accedere ai parametri in GET di una richiesta HTTP proveniente da un form di ricerca:
es:
Abbiamo bisogno di due files: [Link] e [Link]
Analizziamo prima il file [Link]

Inserisci autore
Cerca

Nel momento in cui clicchiamo sul tasto Cerca, vedhiamo che viene effettuata una richiesta al file [Link] e che, viene aggiunto un
parametro con il valore di ricerca che abbiamo inserito noi.
Se usiamo "Pippo" come chiave di ricerca, il browser viene indirizzato alla pagina:
[Link]
Analizziamo ora il file [Link]
< ?php
$author = $_GET['author'];

$author = filter_var($author, FILTER_SANITIZE_STRING);

$authors = [
'Stephen King' => 'Stephen Edwin King (Portland, 21 settembre 1947) e' uno scrittore e sceneggiatore
statunitense',
'Arthur Conan Doyle' => 'Sir Arthur Ignatius Conan Doyle (Edimburgo, 22 maggio 1859 – Crowborough, 7 luglio
1930) e' stato uno scrittore scozzese',
'Agatha Christie' => 'Dame Agatha Mary Clarissa Miller, Lady Mallowan, nota come Agatha Christie (Torquay, 15
settembre 1890[1] – Wallingford, 12 gennaio 1976), e' stata una scrittrice britannica.'
];
if (!in_array($author, array_keys($authors))) {
$error = 'Autore non trovato';
}
$result = $authors[$author];
?>
< !DOCTYPE html>
< html>
< head>
< title>< /title>
< /head>
< body>
< h1>Risultati di ricerca per: < ?php echo $author ?>< /h1>
< ?php
if ($error): ?>
< p style="color: red">< ?php echo $error ?>< /p>
< ?php else: ?>
< p>< ?php echo $result ?>< /p>
< ?php endif ?>
< /body>
< /html>
Analizziamo il codice.
La prima riga di nostro interesse e' quella in cui accediamo all'array speciale $_GET.
Questo array viene automaticamente popolato con i parametri che vengono passati in GET.
Nel nostro caso il campo di input in cui abbiamo inserito l'autore si chiama author, di conseguenza la chiave dell'array in cui troviamo il
valore ricercato ha il medesimo nome.
La riga successiva utilizza la funzione filter_var() vista nella lezione precedente per sanitizzare il dato ricevuto. Ricordiamoci che e'
fondamentale validare tutti i dati che vengono immessi dagli utenti per ridurre al minimo i problemi di sicurezza. Il resto del codice e'
puramente di esempio ed infatti e' mancante di un reale sistema di ricerca.

METODO POST

Il metodo POST non passa i parametri in query string e quindi non possono essere tracciati nemmeno negli access log dei web server.
Di solito si usa una richiesta POST per l'invio di dati personali
Anche qui abbiamo due file: [Link] e [Link]
Analizziamo il [Link]
< !DOCTYPE html>
< html>
< head>
< title>
< /head>
< body>
< form action="[Link]" method="post">
< input type="text" name="username" placeholder="Inserisci lo username" />
< input type="password" name="password" placeholder="Inserisci la password" />
< input type="submit" value="Registrati" /> < /form>
< /body>
< /html>
Analizziamo ora la pagina [Link]:

< ?php
$username = $_POST['username'];
$password = $_POST['password'];
$username = filter_var($username, FILTER_SANITIZE_STRING);
$password = filter_var($password, FILTER_SANITIZE_STRING);
if (!$username || !$password) {
$error = 'Username e password sono obbligatori';
}
?>
< !DOCTYPE html>
< html>
< head>
< title>< /title>
< /head>
< body>
< h1>Risultati Registrazione< /h1>
< ?php if ($error): ?>
< p style="color: red">< ?php echo $error ?>< /p>
< ?php else: ?>
< p>Benvenuto < ?php echo $username ?>< /p>
< ?php endif ?>
< /body>
< /html>

Gestire i Cookie con PHP

I cookie sono una sorta di identificativo che viene utilizzato dai siti Web per memorizzare in fo relative agli utenti.
Questo strumento ci consente di realizzare, ad esempio, un meccanismo di autenticazione e di riconoscere se un utente e' ancora loggato
sul sito oppure no.
I cookie vengono memorizzati automaticamente dal browser, quindi fino alla cancellazione continuerannoad identificare l'utente.
E' possibile anche impostare una data di scadenza in modo che sia il sito Web a decidere per quanto tempo salvare questa info.
In PHP i cookie sono memorizzati all'interno dell'array riservato $_COOKIE
Effettuando un dump dell'array otterremo un'info simile alla seguente:
es:
var_dump($_COOKIE);
array(3) {
["__utma"]=>
string(55) "111872281.2010784770.1481539931.1481977233.1481996919.4"
["__utmc"]=>
string(9) "111872281"
["__utmz"]=>
string(70) "[Link]=(direct)|utmccn=(direct)|utmcmd=(none)"
}

Accedere al valore di un cookie

Per accedere al valore di un singolo cookie basta accedere al singolo elemento dell'array.
Supponiamo di avere un cookie chiamato user_id, possiamo stampare il suo valore con:
echo $_COOKIE["user_id"];

Aggiungere un nuovo cookie

Per generare un nuovo cookie, introduciamo la funzione setcookie() con la quale impostare anche la durata oltre al nome e al valore.
Notiamo pero' che i cookie fanno parte dell'header di una risposta HTTP, quindi e' necessario eseguire queste operazioni prima che
venga inviata la risposta del server.
Ovvero bisognerebbe compiere le operazioni di scrittura dei cookie prima che venga prodotto qualsiasi output.
es:
setcookie("user_id", "345"; strtotime("+1 year"));
La funzione setcookie() prende in ingresso i seguenti parametri:

name
value => valore del cookie (345)
expire
path => percorso per cui e' valido
domain
secure => indica se il cookie dovrebbe essere trasmesso attraverso connessione HTTPS
httponly => indica se il cookie e' accessibile solo attraverso il protocollo HTTP. Questo implica che seil valore e' true il cookie non
e' accessibile da JavaScirpt

Modificare valore di un cookie

Per modificare qualsiasi info relativa ad un cookie e' sufficiente richiamare la funzione setcookie() con i nuovi dati

Eliminare un cookie

L'eliminazione di un cookie avviene come per la chiave di un array attraverso l'invocazione della funzione unset().
es:
unset($_COOKIE["user_id"]);

Gestire le sessioni in PHP

Le sessioni sono un meccanismo alternativo ai cookie per memorizzare info relative all'utente.
A differenza dei cookie che vengono salvati sul client, la sessione memorizza le info sul server che ospita l'applicazione.
Di default la sessione salva i dati in file testuali salvati nel file system del server. E' possibile modificare tale configurazione in modo da
salvarle anche su DB.
L'associazione utente/sessione avviene attraverso un cookie che contiene l'id della sessione.
Un altro metodo con cui e' possibile accedere alla sessione consiste nel passare come parametro in query string il PHPSESSID.
es:
[Link]
Questa modalita' e' SCONSIGLIATA per motivi di sicurezza!
La durata di una sessione puo' essere decisa dallo sviluppatore oppure scadra' alla chiusura del browser.
L'uso piu' comune e' quello di implementare un sistema di autenticazione su un sito Web. Una volta verificato che le credenziali di
accesso sono valide, e' utile memorizzare le info dell'utente su una sessione cosi' da non doverle ricaricare da DB all'apertura della
pagina.

Inizializzare una sessione

Per poter essere utilizzata, bisogna prima inizializzare la sessione. Come per i cookie, bisogna inizializzarla prima che qualsiasi output
sia gia sato inviato alla pagina.
La funzione per inizializzare una sessione si chiama session_start() che prende in ignresso un array di opzioni che, se impostate, vanno a
sovrascrivere quelle di default impostate nel [Link]. Una volta inizializzata la sessione possiamo accedere ai dati relativi e, in caso,
aggiungerne altri.
Se non abbiamo modificato la configurazione PHP e facciamo un dump dell'array $_COOKIE, noteremo che e' stata creata una entry
chiamata PHPSESSID che contiene l'id della sessione appena generata.

Accedere ai dati di una sessione

Una volta inizializzata una sessione, le info sono salvate all'interno dell'array $_SESSION.
es:
Supponiamo di voler memorizzare il nome dell'utente in sessione, possiamo creare una chiave nell'array:
< ?php
session_start();
$_SESSION["name"] = "Simone";
echo $_SESSION["name"]; //stampera' il nome in sessione
Come per i cookie, possiamo rimuovere una proprieta' attraverso unset($_SESSION["chiave"]);).
Se volessimo invece rimuovere TUTTE le variabili in sessione utilizziamo la funzione session_unset(); Se infine volessimo distruggere
una sessione, ad esempio al logout di un utente, usiamo la funzione session_destroy();

Mantenere la sessione tra diversi file

Una sessione inizializzata in un file non viene mantenuta automaticamente se accediamo ad un'altra pagina.
Ragion per cui all'inizio di ogni file che utilizziamo e' necessario richiamare session_start() che, nel caso in cui la sessione sia gia' stata
creata, la recupera con i dati salvati in precedenza.

Gestire delle password con PHP

E' buona norma aumentare il lvl di sicurezza delle nostre applicazioni evitando di memorizzare le password in chiaro nel DB.
Una buona pratica consiste nel memorizzare un hash da cui si puo' verificare che la password inserita dall'utente sia corretta.

MD5 e SHA1

Fino a qualche anno fa le strategie di hasing erano la codifica in MD5 o in SHA1.

es:
$password = "laMiaPassword";
$hash = md5($password);
//oppure
$hash = sha1($password);
Il vantaggio di queste due tipi di codifiche e' che sono one-way, ovvero non esiste un algoritmo capace di decodificarli.
Questa strategia non e' molto efficace online dato che esistono moltissimi tool che attraverso delle rainbow table sono in grado di
restituire la stringa iniziale partendo dall'hash.
Altre strategia consistono nel combinare tra di loro o di applicare piu volte tali algoritmi alla stringa da criptare.
Un'altra strategia consiste nel combinare un salt alla password, cioe' una stringa di caratteri casuali che dovrebbe aumentare la
complessita'.
es:
$password = "lamiapassword";
$salt = "1dgh(3l@"; $hash = mdt($password.$salt);
Il problema di tutte queste soluzioni e' che l'algoritmo di codifica e' veloce, quindi un malintenzionato puo' eseguire miliardi di tentativi
al secondo su una sola CPU.

La funzione crypt()

Una valida alternativa piu' sicura in PHP e' l'uso della funzione crypt() che prende in ingresso due parametri:

$str => la stringa da criptare

$salt => il salt da applicare (opzionale)
Tale funzione utilizza l'algoritmo standard DES.
es:
$password = 'LaM1aPassW0rd';
echo 'Standard DES: ' . crypt($password, 'rl') . "\n";
echo 'Extended DES: ' . crypt($password, '_J9..rasm') . "\n";
echo 'MD5: ' . crypt($password, '$1$rasmusle$') . "\n";
echo 'Blowfish: ' . crypt($password, '$2a$07$usesomesillystringforsalt$') . "\n";
echo 'SHA-256: ' . crypt($password, '$5$rounds=5000$usesomesillystringforsalt$') . "\n";
echo 'SHA-512: ' . crypt($password, '$6$rounds=5000$usesomesillystringforsalt$') ."\n";
Gli output che otterremo sono simili ai seguenti:

Una volta che la password e' stata codificata e memorizzata, per assicurarsi che l'utente stia tentando l'accesso con la password corretta,
abbiamo bisogno della funzione hash_equals() che prende in ingresso due parametri:

hash della password attesa

hash della password immessa dall'utente

es:
$password = 'LaM1aPassW0rd'; //password valida
$hashedPassword = crypt($password, '$2a$07$usesomesillystringforsalt$'); //hash memorizzato nel database
$userPassword = 'LaM1aPassW0rd'; //password inserita dall'utente nel login
$hashedUserPassword = crypt($userPassword, '$2a$07$usesomesillystringforsalt$');
if(hash_equals($hashedPassword, $hashedUserPassword)) {
echo "Accesso effettuato con successo";
} else {
echo "La password inserita non è corretta";
}
Che restituira':

L'unico problema nell'uso della funzione crypt e' la macchinosita' di utilizzo.

Gestione delle password con PHP: password_hash()

Per risolvere la macchinosita' della funzione crypt() e' stata introdotta la funzione passowrd_hash(String $password, integer$algo[,
array $options ]) che accetta tre parametri:

password da codificare
algoritmo da utilizzare per la codifica come:
PASSWORD_DEFAULT
PASSWORD_BCRIPT

es:
$password = 'LaM1aPassW0rd';
$hash = password_hash($password, PASSWORD_DEFAULT);

// l'hash sar� simile a $2y$10$xjX7pVRvyMTgJrplRWyS0O7Fx2iNGEq9iZTdRWk0BTsRWeCoI1xem

$hash = password_hash($password, PASSWORD_BCRYPT);
// l'hash sar� simile a $2y$10$VuCi8po/wzdWfGH7G52okuM.o41mv7kkTrkTb09zlsJcEyujL2k6.

Anche la funzione passowrd_hash ha una sua funzione di verifica dell'hash, chiamata passowrd_verify() che prende in ingresso due
parametri:

$password => la password da verificare

$hash => hash da comparare

Vediamo quindi un esempio completo di simulazione login:

$password = 'LaM1aPassW0rd'; // password valida
$hashedPassword = password_hash($password, PASSWORD_DEFAULT); // hash memorizzato nel database
$userPassword = 'LaM1aPassW0rd'; // password inserita dall'utente nel login
if (password_verify($userPassword, $hashedPassword)) {
echo "Accesso effettuato con successo";
} else {
echo "La password inserita non è corretta";
}

Funzioni PHP per JSON

JSON e' una formato utilizzato per lo scambio di dati.
es:
{
"firstName": "Simone;
"lastName": "Rossi";
"birthdate": "2000-01-01";
"country": "IT";
}
E' un linguaggio molto semplice da leggere e PHP ci mette a disposizione due funzioni per convertire una stringa JSON in un oggetto o
in un array e viceversa.

Convertire una stringa JSON in PHP

La funzione per decodificare una stringa JSON si chiama json_decode() e prende in ingresso due parametri:

$json => stringa JSON da decodificare

$assoc => booleano che indica se convertire la stringa in un oggetto. (default e' false)

es:
Supponiamo di avere la sringa proposta in precedenza all'interno di una variabile e vediamo come convertirla in un array associativo:
$jsonUser = '{"firstName":"Simone","lastName":"D\'Amico"}';
$user = json_decode($jsonUser, true);
print_r($user);
Il risultato che otteniamo sara':

In caso di stringa malformata, verra' restituito null, ma possiamo usare la funzione json_last_error_msg() per restituire l'errore relativo:
es:
// la stringa contiene una virgola di troppo dopo il nome
$jsonUser = '{"firstName":"Simone",}';
$user = json_decode($jsonUser, true);
echo json_last_error_msg();

La funzione restituira':

Convertire un Array in JSON

Supponiamo di avere un array e vogliamo convertirlo in stringa JSON. In questo caso useremo la funzione json_encode() che restituira'
la stringa corrispondente in JSON.
es:
$user = [ 'firstName' => 'Simone',
'lastName' => 'D\'Amico',
'age' => 30
];
echo json_encode($user);
Restituira':
'Simone', 'lastName' => 'D\'Amico', 'age' => 30 ]; echo json_encode($user); ?>

Generare file JSON da Database

NOTA: In questa sezione si fara' uso dell'estensione PDO che ci consente di accedere al DB ed effettuare query.

Struttura dati

Prima di iniziare, bisogna creare una struttura dati e popoliamola con alcuni dati di prova:
es:
CREATE TABLE user (
id INT UNSIGNED NOT NULL AUTO_INCREMENT ,
firstName VARCHAR(100) NOT NULL ,
lastName VARCHAR(100) NOT NULL ,
email VARCHAR(100) NOT NULL ,
PRIMARY KEY ('id')
) ENGINE = InnoDB;
INSERT INTO user (id, firstName, lastName, email)
VALUES (NULL, 'Simone', 'D\'Amico', 'simone@[Link]'),
(NULL, 'Mario', 'Rossi', 'mario@[Link]');

Connessione al DB

Una volta creata la struttura dati, dobbiamo creare la connessione al DB che ci permettera' di effettuare le query per recuperare i dati:
es:
$user = 'root';
$password = 'root';
$db = 'test';
$host = 'localhost';
$port = 8889;
$conn = new PDO("mysql:host=$host; dbname=$db; port=$port", $user, $password);

Recuperare dati e convertirli in JSON

Ora che abbiamo effettuato la'ccesso al DB, possiamo effettuare le nostre query e convertire il risultato in un arary JSON popolati con gli
utenti presenti nel DB.
es:
$result = [];
$stmt = $conn->query("SELECT * FROM user");
while($row = $stmt->fetch(PDO::FETCH_ASSOC)){
$result[] = $row;
}
echo json_encode($result);
In questo esempio verra' effettuata una query al DB per recupeare gli utenti; ciclando sui risultati, creiamo un array che li possa contenere
tutti.
A questo punto grazie alla funzione json_encode() possiamo restituire l'array in formato JSON.

Ecco il risultato che avremmo ottenuto: [

{
id: "1",
firstName: "Simone",
lastName: "D'Amico",
email: "simone@[Link]"
},
{
id: "2",
firstName: "Mario",
lastName: "Rossi",
email: "mario@[Link]"
}
]

Funzioni PHP per XML

xML(eXtensible Markup Language) e' un metalinguaggio per la definizione di linguaggi di markup. Come JSON, l'XML e' utilizzato
anche per generare documenti che possono essere letti da applicazioni.
es:
< ?xml version="1.0" encoding="UTF-8"?> < user>
< firstName>Simone< /firstName>
< lastName>DAmico< /lastName>
< birthDate>2000-01-01< /birthDate>
< country>IT< /country>
< /user>

Accedere ad un documento XML con PHP

PHP mette a disposizione degli strumenti che ci consentono di leggere e creare file XML.
es:
Data una stringa che rappresenta un doc XML, vediamo come accedere alle singole proprieta':
$xml = <<< XML
< ?xml version="1.0" encoding="UTF-8"?>
< user>
< firstName>Simone< /firstName>
< lastName>DAmico< /lastName>
< birthDate>2000-01-01< /birthDate>
< country>IT< /country>
< /user>
XML;
$user = new SimpleXMLElement($xml);
var_dump($user);
La classe SinpleXMLElement ci consente di convertire una stringa XML in un oggetto che possiamo manipolare agevolemente.
Ecco il risultato dell'esempio:
object(SimpleXMLElement)#1 (4) {
["firstName"]=>
string(6) "Simone"
["lastName"]=>
string(6) "DAmico"
["birthDate"]=>
string(6) "2000-01-01"
["country"]=>
string(6) "IT"
}
Al momento possiamo limitarci ad accedere ai singoli valori contenuti nelle proprieta' dell'utente trasformando l'oggeto in un semplice
array ed eseguire le operazioni direttamente sull'array ottenuto:
es:
$user = (array) new SimpleXMLElement($xml);
var_dump($user);
echo $user["firstName"];

Convertire un array in una stringa XML

Finora abbiamo visto come leggere una stringa XML e convertirla in un array PHP, adesso vediamo come fare il contrario partendo da
un array:
es:
object(SimpleXMLElement)#1 (4) {
["firstName"]=>
string(6) "Simone"
["lastName"]=>
string(6) "DAmico"
["birthDate"]=>
string(6) "2000-01-01"
["country"]=>
string(6) "IT"
}
Otterremo il seguente risultato:
< ?xml version="1.0"?> < user>< firstName>Simone< /firstName>< lastName>D'Amico< /lastName>< age>30< /age><
/user>
Nell'esempio abbiamo creato un nuovo oggetto SimpleXMLElement e, ciclando su tutte le proprieta' dell'array, le abbiamo aggiunte al
user.
A questo punto attraverso il metodo asXML() abbiamo restituito la stringa contenente l'XML.

Generare file XML da DB

In questa sezione vedremo come utilizzare le funzioni per realizzare un file XML recuperando le info dal DB.
Anche qui useremo l'estensione PDO che ci consente di accedere al DB ed effettuare le necessarie query

Struttura dati

Creiamo la nostra struttura dati:

es:
CREATE TABLE user (
id INT UNSIGNED NOT NULL AUTO_INCREMENT ,
firstName VARCHAR(100) NOT NULL ,
lastName VARCHAR(100) NOT NULL ,
email VARCHAR(100) NOT NULL ,
PRIMARY KEY (`id`)
) ENGINE = InnoDB;
INSERT INTO user (id, firstName, lastName, email)
VALUES (NULL, 'Simone', 'D\'Amico', 'simone@[Link]'),
(NULL, 'Mario', 'Rossi', 'mario@[Link]');

Connessione al DB

Effuttuiamo la connessione al DB che ci permettera' di effettuare le query per recuperare i dati:

es:
$user = 'root';
$password = 'root';
$db = 'test';
$host = 'localhost';
$port = 8889;
$conn = new PDO("mysql:host=$host; dbname=$db; port=$port", $user, $password);

Recuperare dati e convertirli in JSON

Effettualiamo le nostre query e convertiamo il risultato in XML con gli utenti presenti nel DB.
es:
$xml = new SimpleXMLElement('< users/>');
$stmt = $conn->query("SELECT * FROM user");
while($row = $stmt->fetch(PDO::FETCH_ASSOC)){
$user = $xml->addChild('user');
foreach ($row as $key => $value) {
$user->addChild($key, $value);
}
}
echo $xml->asXML();
Questo esempio restituira':
< ?xml version="1.0"?>
< users>

< id>1< /id>

< firstName>Simone< /firstName>
< lastName>D'Amico< /lastName>
< email>simone@[Link]< /email>
< /user>
< user>
< id>2
< firstName>Mario< /firstName>
< lastName>Rossi< /lastName>
< email>mario@[Link]< /email>
< /user>
< /users>

Gestire file con PHP

PHP mette a disposizione diverse funzioni per lavorare con il file system, dai costrutti per leggere e scrivere file a quelli per creare
directory o modificare i permessi:

file_exists() => controlla se un file o directory esiste prendendo in input il path del file da verificare e restituire un booleano
is_file() => verifica se il path passato come parametro e' un file e restituisce un booleano
filesize() => restituisce la dimensione di un file in bytes. Nel caso in cui il file non esiste non non e' possibile calcolarne la
dimensione, restituisce false
file_get_contents() => restituisce una stringa con il contenuto di un file prendendo in input il path del file
file_put_contents() => scrive una stringa all'interno di un file e prende in input 3 parametri:
1. path del file
2. dati da scrivere
3. flag
copy() => consente di copiare un file in un path di destinazione e prende due parametri in input:
1. path sorgente
2. path destinazione
E restituire true se la copia va a buon fine, false altrimenti
unlink() => cancella un file dal file system e prende in ingresso il path del file e restituisce un booleano true se ' stato cancellato,
altrimenti false

Manipolare le immagini con PHP e GD

GD e' l'estensione grafica di PHP e consente di creare immagini con figure geometriche semplici.
es:
header ("Content-type: image/png");

$handle = imagecreate (200, 50) or die ("Impossibile creare l'immagine");

$backgroundColor = imagecolorallocate($handle, 255, 255, 0);
$textColor = imagecolorallocate($handle, 0, 0, 0);
imagestring($handle, 10, 31, 18, "Ciao da [Link]", $textColor);
imagepng($handle);
Tale esempio restituira'un rettangolo giallo con scritto "Ciao da [Link]"
Analizziamo il codice riga per riga:
 Content Type => ci permette di modificare il tipo della risposta in modo tale che il browser sappia che deve interpretare il file
come un'imamgine e non come un file HTML
imagecreate() => prende in ingresso le dimensioni dell'immagine (lunghezza - larghezza) e restituisce una risorsa di tipo
"immagine"
imagecolorallocate() => alloca un colo per l'immagine prendendo in input una risorsa di tipo immagine e i valori RGB
imagestring() => disegna una stringa all'interno dell'immagine prendendo in ingresso i seguenti parametri:
risorsa di tipo imamgine
dimensione font
posizione asse X a partire dall'angolo alto sx
posizione asse Y a partire dall'algolo alto sx
stringa da disegnare
identificativo del colore con cui disegnare la stringa
imagepng() => stampa a schermo il risultato prendendo in ingresso la risorsa

Ritagliare una porzione di immagine con PHP

Oltre che creare immagini, possiamo anche caricarne di esisteni ed eseguire operazioni su di esse. Un caso frequente e' quello di
ritagliarne una parte:
es:
header ("Content-type: image/png");
$handle = imagecreatefrompng('[Link]');
$size = min(imagesx($handle), imagesy($handle));
$imageCropped = imagecrop($handle, [
'x' => 0,
'y' => 0,
'width' => $size,
'height' => $size
]);
imagepng($imageCropped);

Realizzare un sistema CAPTCHA con PHP

CAPTCHA (completely automated public Turing test to tell computers and humans apart) e' un sistema per determinare se l'utente che
sta compiendo una determinata operazione sia umano e non un computer.
Realizzeremo un semplice sistema CAPTCHA da integrare nelle pagine Web a partire da una form di contatto con i campi:

nome
cognome
messaggio
submite

< !DOCTYPE html> < html> < head> < meta charset="utf-8"> < title>Captcha Example< /title> < /head> < body> <
form action="[Link]" method="post"> < label>First Name < input type="text" name="firstName" />< /label>
< label>Last Name < input type="text" name="lastName" />< /label>
< label>Message < textarea name="message">< /textarea>< /label>

< input type="submit" name="submit">

< /form>
< /body>
< /html>

Immagine CAPTCHA

Prima di integrare l'immagine all'interno de lform, bisogna scrivere il codice necessario alla sua generazione.
Creiamo un nuovo file [Link] ed inseriamo il codice per creare il background dell'immagine:
< ?php
//creazione dell'immagine e aggiunta di un background di colore grigio
$image = imagecreatetruecolor(120, 30);
$background = imagecolorallocate($image, 200, 200, 200);
imagefill($image, 0, 0, $background);
Una volta realizzata la base, inseriamo delle linee di disturbo per evtiare che i bot riconoscano facilmente il CAPTCHA:
$linesColor = imagecolorallocate($image, 100, 100, 100);
for ($i=1; $i<=5; $i++) {
imagesetthickness($image, rand(1,2));
imageline($image, 0, rand(0,30), 120, rand(0,30), $linesColor);
}
A questo punto creiamo la stringa che conterra' le cifre del CAPTCHA:
$captcha = '';
$textColor = imagecolorallocate($image, 0, 0, 0);
for ($x = 15; $x <= 95; $x += 20) {
$value = rand(0, 9);
imagechar($image, rand(3, 5), $x, rand(2, 14), $value, $textColor); $captcha .= $value;
}
Ora restituiamo l'immagine in formato PNG ed inseriamola all'interno del form: Nel file [Link] aggiungiamo: header("Content-
type: image/png");
imagepng($image);
imagedestroy($image);
Ora in [Link] inseriamo il nostro php:
< p>< img src="./[Link]" />< /p>
< label>CAPTCHA < input type="text" name="captcha" />

Questo sara' il risultato:

Getire valore del CAPTCHA in sessione

Ora che abbiamo generato l'immagine, dobbiamo memorizzare in sessione il valore della variabile $captcha in modo da verificare che il
valore immesso dall'utente sia corretto.
Il primo step e' inizializzare la sessione nel file [Link]
< ?php
session_start();
A questo punto salviamo in sessione il valore generato all'interno dell'immagine, quindi, una volta generata la stringa casuale
aggiungiamo:
$_SESSION["captcha"] = $captcha;
In questo modo all'interno dell'array, oltre alle info di sessione, ci sara' anche il valore da verificare al submit del form

Verificare che il CAPTCHA sia valido

Una volta memorizzato il valore in sessione, possiamo gestire il submit del form e il controllo di validita' del codice.
Creiamo quindi il file [Link] che conterra' il codice di gestione form:
< ?php
session_start();
//se accediamo al file senza eseguire il submit della form
if (!isset($_POST['submit'])) {
die('I dati non sono validi');
}
if ($_POST['captcha'] != $_SESSION['captcha']) {
die('Codice non valido');
}
echo 'Codice valido.';
Questo codice verifica che il valore inviato del CAPTCHA corrisponda a quello in sessione. In caso negativo termina l'esecuzione dello
script con un errore, altrimenti si puo procedere con l'invio della mail.
Il file [Link] viene richiamato dal form dato che lo avevamo definito come valore della proprieta' action

Inviare email con PHP

La funzione PHP con cui inviare email si chiama mail() e prende in input 3 parametri:

1. mail destinatario
2. oggetto mail
3. contenuto mail

La funzione infine restituira' un booleano che indica se l'invio e' andato a buon fine o meno

Inviare email a destinatari multipli

Il parametro $to della funzione mail($to, $subject, $message); e' una stringa che puo contenere uno o piu destinatari.
Pero nel caso in cui i destinatari siano multipli, vanno separati con una virgola, o racchiusi in una variabile, come nell'esempio:
es:
$receivers = implode(", " , [
"Mario Rossi < info@[Link]>",
"Luca Bianchi < info@[Link]>"
]);
mail($receivers, "oggetto", "messaggio);
Inviare mail da un form di contatto

Vediamo come utilizzare le info viste finora creando un form di contatto:

Iniziamo con la form HTML
< !DOCTYPE html>
< html>
< head>
< meta charset="utf-8">
< title>Contact Form< /title>
< /head>
< body>
< form action="[Link]" method="post"> < input type="text" name="name" placeholder="Il tuo nome completo" />
< input type="email" name="email" placeholder="Il tuo indirizzo email" />
< input type="subject" name="subject" placeholder="Oggetto" />
< textarea name="message" rows="8" cols="80" placeholder="Il tuo messaggio">< /textarea>
< input type="submit" />
< /form>
< /body>
< /html>
Che produrra' il seguente form:
Il tuo nome completo
Il tuo indirizzo email
Oggetto
Il tuo messaggio

Submit

Ora creiamo il file [Link] che si occupera' di inviare una mail di conerma all'utente e una mail con i contenuti inseriti dall'utente a noi:
< ?php
$adminEmail = 'admin@[Link]';
$userEmail = filter_var($_POST['email'], FILTER_SANITIZE_EMAIL);
$userMessage = '
< html>
< head>
< title>Grazie per averci contattato< /title>
< /head>
< body>
< h1>Grazie per averci contattato< /h1>
< p>La tua richiesta è stata inoltrata. Ti risponderemo al più presto.< /p>
< p>Lo Staff< /p>
< /body>
< /html>
';
$adminMessage = "
< html>
< head>
< title>Contatto dal sito web< /title>
< /head>
< body>
< h1>Contatto dal sito web< /h1>
< ul>
< li>Nome: {$_POST['name']}< /li>
< li>Oggetto: {$_POST['subject']}< /li>
< li>Messaggio: {$_POST['message']}< /li>
< /ul>
< /body>
< /html>
";
$headers[] = 'MIME-Version: 1.0';
$headers[] = 'Content-type: text/html; charset=utf-8';
mail($userEmail, 'Richiesta di contatto effettuata con successo', $userMessage, implode("\r\n", $headers));
mail($adminEmail, 'Richiesta di contatto dal sito web', $adminMessage, implode("\r\n", $headers));
echo "Messaggio inviato con successo";
?>