Se hai un sito web in cui memorizzi dati dell’utente è probabile che si utilizzi un database, come MySQL, SQLite o altro, ed è importante assicurarsi che il proprio database sia sicuro da e per gli utenti.

Creare istruzioni di query al volo come la sequente:

$sql = "INSERT INTO commenti (nome, commento) VALUES (".$nome.",".$commento.")";

è considerata una cattiva pratica che può essere facilmente superata, eliminando la maggior parte dei problemi, utilizzando dichiarazioni SQL prepare.

Realizzare istruzioni SQL come la precedente può essere rischioso. Se un utente malizioso invia, tramite il modulo del commento, una istruzione SQL appositamente predisposta, è possibile eseguire query al database. Invece, è necessario utilizzare dichiarazioni prepare come questa:

$sql = $db->prepare('INSERT INTO commenti (nome, commento) VALUES (?,?)');

aggiungere poi i valori singolarmente

$sql->bindParam(1, $nome);
$sql->bindParam(2, $commento);

e infine eseguire la query

$sql->execute();

Si trattano di poche righe in più, ma che rendono il vostro codice molto più sicuro.

Non solo il database deve essere al sicuro contro le query non intenzionali, ma anche gli utenti.
Se qualcuno è in grado di memorizzare un commento che sarà visualizzato da tutti gli altri utenti, allora l’input deve essere limitato a quello che ci aspettiamo, come in questo caso solo testo. Se invece permettiamo di scrivere codice HTML, un utente malizioso potrebbe caricare un malware da un altro sito, il classico exploit XSS.

Una soluzione semplice può essere l’utilizzo di funzioni per sterilizzare l’input, dunque sostituire, come nel caso citato, i tag HTML con quelli innocui.
Ad esempio, in un codice PHP che si interfaccia con un database MySQL è possibile utilizzare:

$nome = mysql_real_escape_string($_POST['nome']);

che inserisce l’escape davanti a caratteri speciali in una istruzione SQL.

Puoi leggere l’articolo su come utilizzare più istruzioni SQL prepare con PHP per approfondire l’argomento, e risolvere il problema di utilizzare più dichiarazioni SQL prepare per l’esecuzione.

mtrack è un’applicazione open source, realizzata in PHP, per il completo controllo di un progetto software/web applicazione.

Permette la gestione del progetto, navigazione del codice, wiki e caratteristiche di time tracking. L’applicazione ha un sistema di tracciamento dei componenti, priorità, gravità e tappe, in base anche alle stime di tempo e fatiche registrate. Inoltre si integra perfettamente con i servizi di repository Subversion, Mercurial e Git per la gestione delle versioni del progetto.

Gli utenti possono ricevere notifiche di aggiornamento del codice del progetto o comunicare con gli altri collaboratori via e-mail.

Inoltre è possibile estendere o personalizzare ulteriormente mtrack attraverso le API offerte.

Xdebug è un’estensione PHP gratuita e open source che permette il debugging e il profiling degli script PHP in dettaglio.

Considerando che è una estensione, l’utilizzo è facile e richiede pochissime configurazione per integrarlo nelle nostre applicazioni.
Xdebug ti aiuta fornendo molte informazioni utili di debug:

• tracce di funzioni e di stack delle variabili nei messaggi di errore con la completa visualizzazione dei parametri delle funzioni definite dall’utente, il nome della funzione, il nome del file e il numero di linea nel codice in cui si è verificato l’errore.
• allocazione di memoria
• protezione da cicli infiniti

Inoltre fornisce informazioni di profiling, un potente strumento che analizza il codice PHP e determina i colli di bottiglia o in generale individua le parti del codice più lente, analisi del code coverage ed ha la capacità di eseguire il debug in modo interattivo attraverso un interfaccia da browser, tramite estensioni per i browser di interagire con l’esecuzione degli scripts PHP.

Una tecnica comunemente usata in programmazione è l’utilizzo delle callback. Una callback è una funzione che data come parametro ad un’altra funzione può essere richiamata nello svolgimento di quest’ultima.

In questo articolo vi mostrerò come definire e richiamare callbacks in PHP, e come può essere utile farne uso.

Supponiamo di avere uno script PHP che quando viene eseguito fa una ricerca del termine su diversi motori di ricerca. Il tutorial non vuole spiegherà come elaborare i risultati di ricerca, ma solo dimostrare come una callback può essere utile.

Implementare l’esempio sopra senza l’utilizzo di callback può essere simile al seguente codice:

<?php
function searchBySearchEngine($term, $searchEngine) {
  $result = array();
  foreach ($searchEngine as $engine( {
    // ricerca termine per ciascun motore di ricerca
    $result[] = array(
      'search_engine' => $engine,
      'result' => 'risultati di ricerca'
    );
  }
  return $result;
}
$searchEngine = array('http://www.google.it', 'http://www.bing.com', 'http://it.yahoo.com', // altri...);
// inizio ricerca del termine sui motori di ricerca
$term = 'MaiNick';
$data = searchBySearchEngine($term, $searchEngine);
// output dei risultati
foreach ($data as $result) {
  echo "Risultati di ricerca di " . $term . " eseguita su " . $result['search_engine'] . "<br />";
}
?>

L’esempio può essere modificato per utilizzare la funzione di callback, richiamata ogni volta che un singolo motore di ricerca ha completato la ricerca.

Ci sono tre tipi di utilizzo di callback:

• una funzione PHP standard: passata come una stringa.
• un metodo statico di una classe: passato come un array in cui il primo elemento è il nome della classe e il secondo è il nome del metodo.
• un metodo di un oggetto: anch’esso passato come prima tramite array, dove il primo elemento è l’oggetto stesso.

Ecco il codice che illustra come definire ogni tipologia di callback:

<?php
// 1 metodo
function myCallback() {
}
$callback = 'myCallback';

// 2 metodo
class MyClass {
  public static function myCallback() {
  }
}
$callback = array('MyClass', 'myCallback');

// 3 metodo
class MyClassObj {
  public function myCallback() {
  }
}
$obj = new MyClassObj();
$callback = array($obj, 'myCallback');
?>

Per verificare se una variabile può essere definita come una funzione, e quindi utilizzato come una callback, possiamo utilizzare is_callable(), una funzione PHP che accetta la callback come unico argomento. Quindi possiamo utilizzare la funzione call_user_func() che permette di richiamare la funzione callback passata come primo argomento e ulteriori argomenti passati come parametri alla callback stessa.

Tornando al nostro esempio iniziale, possiamo modificare la funzione searchBySearchEngine in modo che prenda come terzo argomento la callback, richiamata ogni volta che un motore di ricerca ha completato la sua ricerca.

<?php
function searchBySearchEngine($term, $searchEngine, $callback = null) {
  $result = array();
  foreach ($searchEngine as $engine( {
    // ricerca termine per ciascun motore di ricerca
    if (is_callable($callback)) {
      $result = call_user_func($callback, $term, $searchEngine);
    }
  }
  return $result;
}

// classe fittizia utilizzate per la callback
class MyClass {
  public static function searchComplete($term, $searchEngine) {
    $values = array(
      'search_engine' => $engine,
      'result' => 'risultati di ricerca'
    );
    echo "Risultati di ricerca di $quot; . $term . " eseguita su " . $values['search_engine'] . "<br />";

    return $values;
  }
}
$searchEngine = array('http://www.google.it', 'http://www.bing.com', 'http://it.yahoo.com', // altri...);
// inizio ricerca del termine sui motori di ricerca
$term = 'MaiNick';
$data = searchBySearchEngine($term, $searchEngine, array('MyClass', 'searchComplete'));
?>

Potere notare che all’esecuzione del codice sopra i messaggi di feedback vengono visualizzati ogni qual volta un motore di ricerca ha restituito dei risultati, e non come nel primo codice al termine dello script.

In questo tutorial di oggi vedremo come creare miniature di immagini con PHP e l’uso della libreria GD.

Caricare sul server immagini in dimensioni originali può essere dispendioso per lo spazio a disposizione ma soprattutto per la banda quando bisogna visualizzarle ad ogni richiesta al server.
In questo caso la libreria GD si rivela utilissima perché permette di poter prendere un’immagine jpg, gif o png e crearne una nuova con dimensioni ridotte, quindi più leggera e più veloce da caricare.
Durante il ridimensionamento delle immagini è inoltre possibile ridefinire il livello di compressione, regolando quindi il rapporto qualità/dimensione, rendendo così più veloce il caricamento della miniatura.

Questa funzione php permette il resize di immagini jpeg, gif e png. I parametri da settare per la funzione sono il nome del file da ridimensionare, la cartella dove è presente l’immagine, la cartella dove salvare la nuova immagine e la larghezza della nuova immagine.
Ho deciso di poter passare solo la larghezza perché una dimensione fissa dei lati dell’immagine potrebbe portare a creare un’immagine che non mantiene le proporzioni e quindi deformata.

Funzione per creare e salvare sul server un’immagine ridimensionata

/**
 * =---------------------------------------------------------------------=
 * createThumbnail
 * =---------------------------------------------------------------------=
 * Questa funzione creerà una miniatura dell'immagine caricata.
 *
 * @param $filename	- nome immagine.
 * @param $dir_in		- directory dove è presente l'immagine.
 * @param $dir_out		- directory dove caricare l'immagine.
 * @param $width_image	- larghezza immagine da creare.
 */
function createThumbnail($filename, $dir_in, $dir_out, $width_image) {
  // apro l'immagine originale (jpeg,gif,png)
  if (preg_match('/[.]jpg$/', $filename)) {
    $im = imagecreatefromjpeg($dir_in.$filename);
  }
  else if (preg_match('/[.]gif$/', $filename)) {
    $im = imagecreatefromgif($dir_in.$filename);
  }
  else if (preg_match('/[.]png$/', $filename)) {
    $im = imagecreatefrompng($dir_in.$filename);
  }
  // calcolo la larghezza e l'altezza dell'immagine originale
  $ox = imagesx($im);
  $oy = imagesy($im);
  // larghezza della miniatura data in input
  $nx = $width_image;
  // altezza calcolata proporzionalmente all'immagine originale
  $ny = floor($oy * ($width_image / $ox));
  // creo l'immagine della miniatura
  $nm = imagecreatetruecolor($nx, $ny);
  // copio l'immagine originale in quella della miniatura ridimensionaldola
  imagecopyresized($nm, $im, 0,0,0,0, $nx, $ny, $ox, $oy);
  // verifico l'esistenza della cartella dove salvare la miniatura
  if (!file_exists($dir_out)) {
    if (!mkdir($dir_out)) {
      die("There was a problem.");
    }
  }
  // salvo l'immagine della miniatura
  if (imagejpeg($nm, $dir_out.$filename)) {
    return TRUE;
  } else {
    return FALSE;
  }
}

Con le prime istruzioni condizionali apriamo l’immagine originale sia che essa sia jpeg, gif e png. Poi memorizziamo le dimensioni (larghezza $ox e altezza $oy) dell’immagine originale e le dimensioni della miniatura da creare; la larghezza $width_image fissa passata in input alla funzione e l’altezza calcolate per mantenere la proporzione e non deformare l’immagine nella miniatura.
Una volta creata la base per la miniatura, andiamo a copiare il contenuto dell’immagine originale con le nuove dimensioni (imagecopyresized()). Copiata l’immagine la salviamo con imagejpeg() nel formato jpeg: il terzo parametro, omesso, rappresenta il grado di compressione che può essere un valore variabile da 0 a 100 (più l’immagine è compressa più è leggera e allo stesso tempo più perde di definizione).

Possiamo modificare l’ultima parte della funzione per salvare l’immagine di miniatura nello stesso formato del file originale utilizzando, come nella prima parte, delle istruzioni condizionali e le rispettive funzioni imagejpeg(), imagegif() e imagepng(), di cui è facile intuire il significato.

In conclusione ricordo che la libreria GD è nativa su PHP a partire dalla versione 4.3.0, questo comporta il non funzionamento della funzione createThumbnail() con una versione di PHP inferiore.

Avendo bisogno di implementare una rubrica in un progetto ho avuto l’esigenza di memorizzare per ciascun contatto un numero non precisato di recapiti.

Per la duplicazione del campo recapito ho utilizzato il plugin jquery relCopy che copia un qualsiasi elemento, e suoi figli, dal DOM. Questo in realtà è uno strumento relativamente semplice che chiunque sarà in grado di utilizzare. Se avete lavorato con altri tipi di plugin di jQuery, o anche solo visto un sito come http://partypoker.it/, allora non dovrebbe essere troppo difficile per voi. Utilizzare questo tipo di plugin risolve il problema, come nel mio caso, di provvedere manualmente a realizzare il codice per duplicare una certa porzione della nostra pagina.
Opzioni del plugin sono:

• excludeSelector (string): selettore jQuery utilizzato per escludere un elemento ed i suoi figli.
• limit (integer): numero di copie permesse [Default 0: illimitato].
• append (string): HTML da allegare alla fine di ogni copia.
• copyClass (string): una classe da associare a ciascuna copia [Default 'copy'].
• clearInputs (boolean): opzione per cancellare i valori dei campi input e textarea clonati [Default true].

Per utilizzarlo basta chiamare $('selettore').relCopy({opzioni}) su un qualsiasi elemento del DOM con un selettore di tipo jQuery definito nell’attributo rel dell’elemento.

Documento HTML

Il modulo visualizzato contiene i campi descrittivi del contatto più la possibilità di associarvi quanti recapiti vogliamo:

<p class="clone"><input type="text" name="recapiti[]" class='input'/></p>
<p><a href="#" class="add" rel=".clone">Aggiungi recapito</a></p>
<p><input type="submit" value="Salva" /></p>

Dopo i campi predefiniti per descrivere un contatto abbiamo un paragrafo con un campo di tipo testo. Il paragrafo ha la classe clone la stessa utilizzata nell’attributo rel del link posto sotto, il quale ha la funzione di clonarlo.

Abbiamo indicato recapiti[] nell’attributo name del campo del recapito in modo da ottenere un array di tutti i recapiti inseriti nell’array globale $_POST: non mettendo le parentesi quadrate il modulo invierebbe il valore dell’ultimo recapito aggiunto.

Script jQuery

Per prima cosa bisogna includere la libreria jQuery (dai server di Google) poi il plugin relCopy ed infine il nostro file di script:

<script type="text/javascript" src="http://ajax.googleapis.com/ajax/libs/jquery/1.3.2/jquery.min.js"></script>
<script type="text/javascript" src="relCopy.jquery.js"></script>
<script type="text/javascript" src="script.js"></script>

Ecco il codice del nostro file di script:

$(document).ready(function(){
  // link inserito alla fine dell'elemento clonato che permette di eliminarlo
  var removeLink = ' <a class="remove" href="#" onclick="$(this).parent().slideUp(function(){ $(this).remove() }); return false">remove</a>';

  // chiamata permette di clonare il paragrafo con all'interno il campo di testo del recapito
  $('a.add').relCopy({ append: removeLink });
});

Tramite la chiamata $('a.add').relCopy({ append: removeLink}); associamo al collegamento la funzione di clonare il recapito. Nell’opzione append utilizzata del plugin abbiamo definito un link che tramite un metodo jQuery permette di eliminare il corrispondente elemento clonato.

Salva contatto in PHP

Il codice che segue scandisce l’array $_POST['recapiti'] per estrarre i singoli valori inseriti:

<?php
if($_POST['recapiti']){
  $array_recapiti = $_POST['recapiti'];
  foreach ($array_recapiti as $recapito) {
    if (strlen($recapito)>0) {
      //operazioni sul singolo recapito
      echo $recapito."<br />";
    }
  }
}
?>

Demo Download

Ieri, il giorno prima della conferenza, è stata dedicato interamente alla formazione costituita da 5 corsi di formazione in parallelo, tutti ospitati da un membro del team del core di symfony.

Tra gli ospiti illustri alla conferenza, Matthew Weier O’Phinney, capo progetto per Zend Framework, parlerà di come sviluppare con Symfony e Zend Framework insieme, e Dustin Whittle, evangelista sviluppatore per la strategia Open di Yahoo.

Per chiudere la seconda giornata della conferenza, ospiterà una sessione su Symfony 2.0 per rivelare poi la prima release alpha.

Maggiori informazioni dal sito dedicato all’evento Symfony Live 2010 e su Twitter utilizzando l’hashtag ufficiale #sflive2010.

Carson McDonald ha scoperto l’errore quando ha cercato di eseguire una dichiarazione prepare in un ciclo su un set di risultati di un’altra istruzione preparata, dichiarata precedentemente il ciclo ma create entrambe sulla stessa connessione.

Cercando dettagli sull’errore generato nella documentazione di MySQL, emerge che il set di risultati di un’istruzione prepare eseguita devono essere scaricati completamente prima di eseguire un’altra istruzione preparata sulla stessa connessione.

Il problema può essere semplicemente risolto utilizzando l’istruzione store_result che trasferisce un set di risultati da una dichiarazione prepare.

Riporto lo stesso esempio analizzato nel suo articolo da McDonald:

< ?php
  $db_connection = new mysqli('127.0.0.1', 'user', '', 'test');
  $post_stmt = $db_connection->prepare("select id, title from post where id = 1000");
  $comment_stmt = $db_connection->prepare("select user_id from comment where post_id = ?");
  if ($post_stmt->execute()) {
    $post_stmt->bind_result($post_id, $title);
    if ($post_stmt->fetch()) {
      $comments = array();
      $comment_stmt->bind_param('i', $post_id);
      if ($comment_stmt->execute()) {
        $comment_stmt->bind_result($user_id);
        while ($comment_stmt->fetch()) {
          array_push($comments, array('user_id' => $user_id));
        }
      } else {
        printf("Comment statement error: %s\n", $comment_stmt->error);
      }
    }
  } else {
    printf("Post statement error: %s\n", $post_stmt->error);
  }

  $post_stmt->close();
  $comment_stmt->close();
  $db_connection->close();

  printf("ID: %d -> %s\n", $post_id, $post_title);
  print_r($comments);
?>

il codice sopra comporterà il seguente errore:

Comment statement error: Commands out of sync; you can't run this command now
PHP Notice:  Undefined variable: post_title in error.php on line 41
ID: 9033 ->
Array
(
)

Inserendo l’istruzione store_result risolviamo il problema:

< ?php
  $db_connection = new mysqli('127.0.0.1', 'user', '', 'test');
  $post_stmt = $db_connection->prepare("select id, title from post where id = 1000");
  $comment_stmt = $db_connection->prepare("select user_id from comment where post_id = ?");
  if ($post_stmt->execute()) {
    //se eseguita correttamente scarico il set di risultati
    $post_stmt->store_result();
    $post_stmt->bind_result($post_id, $title);
    if ($post_stmt->fetch()) {
      $comments = array();
      $comment_stmt->bind_param('i', $post_id);
      if ($comment_stmt->execute()) {
        $comment_stmt->bind_result($user_id);
        while ($comment_stmt->fetch()) {
          array_push($comments, array('user_id' => $user_id));
        }
      } else {
        printf("Comment statement error: %s\n", $comment_stmt->error);
      }
    }
    $post_stmt->free_result();
  } else {
    printf("Post statement error: %s\n", $post_stmt->error);
  }

  $post_stmt->close();
  $comment_stmt->close();
  $db_connection->close();

  printf("ID: %d -> %s\n", $post_id, $post_title);
  print_r($comments);
?>

Come è stato utile per me, spero di aver fatto cosa buona anche per voi.
Se avete utilizzato un’altra soluzione datemene notizia nei commenti.

[Fonte: IONCANNON]

Conversioni di tipo implicite

I casi più frequenti in cui avvengono conversioni implicite (automatiche) di tipo sono i seguenti:

• Operatori aritmetici binari. Se un operando è un intero e l’altro è un numero a virgola mobile, il valore intero viene convertito in float. Se uno è una stringa e l’altro è un intero, PHP converte la stringa in un intero prima di valutare entrambi gli operandi come interi.
• Espressioni booleane e operatori di espressione. Nel caso in cui un’espressione deve essere valutata come un booleano, PHP converte il risultato dell’espressione in un booleano.
• Alcuni metodi che richiedono le stringhe. Alcuni metodi e operatori, echo, print o l’operatore di concatenazione della stringa (.), richiedono che i loro operandi siano stringhe.

Conversioni di tipo esplicite

Si tenta la conversione di tipo utilizzando il cosiddetto type casting: si fa precedere una variabile (o una qualsiasi espressione) da un tipo di dato racchiuso tra parentesi e php prova a convertirla.

• (float), (double), (real) Converte in un numero a virgola mobile.
• (int), (integer) Converte in un intero.
• (string) Converte in una stringa di testo.
• (bool), (boolean) Converte in un valore booleano.
• (array) Converte in un array.
• (object) Converte in un oggetto.

<?php
    $strQta = $_POST['qtaDesiderata'];
    $strQta = (int)$strQta;
?>

Conversioni di tipo specifiche

Conversione in interi

E’ possibile convertire esplicitamente i valori in interi utilizzando anche la funzione intval. Quando si convertono i valori a virgola mobile in interi, php tronca la parte decimale. Quando si converte una stringa in un intero, php analizza la stringa un carattere alla volta finché trova un carattere che non è una cifra; il mancato parsing di un numero decimale valido restituisce il valore 0.

<?php
    echo (int)"123";  //visualizza 123
    echo (int)"+456";  // 456
    echo (int)"55e2";  // 55 - il parsing si ferma alla e
    echo (int)"3 cani"; // 3 - il parsing si ferma allo spazio
    echo (int)"tre cani"; // 0 - non interpretati num scritti in lettere
    echo (int)"-4321"; // -4321
?>

Quando si convertirà da un booleano in un intero, FALSE restituirà 0 mentre TRUE restituirà 1. La conversione da array, oggetti o risorse in interi è indefinita e non dovrebbe essere eseguita. Il valore NULL è convertito sempre nel valore intero 0.

Conversione in numeri in virgola mobile

Le varibili e le espressioni possono essere convertite nel tipo a virgola mobile anche chiamando la funzione floatval.

Un intero convertito in numero a virgola mobile potrebbe non essere identico al valore intero originale ( 10000 generi un valore a virgola mobile 9999.9999999 o anche 10000.000001). Non si dovrebbe mai fare affidamento su confronti con valori a virgola mobile. Quando si convertono le stringhe, qualsiasi stringa numerica contenente un decimale (.) o la lettera e può essere convertita in un valore a virgola mobile.

<?php
    $f1 = (float)"+123";  // 123.0
    $f2 = (float)"-123";  // -123.0
    $f3 = (float)"123.456";  // 123.456
    $f4 = (float)"1.23456e2";  // 123.456
    $f5 = (float)"1.234e-2";  // 0.01234
    $f6 = (float)"1000000000000";  //1e12 (mille miliardi)
?>

Per il resto avviene come nella conversione in interi, in più specificata la parte decimale.

Conversione in stringhe

E’ possibie convertire le variabili in stringhe chiamando la funzione strval o racchiudendole tra virgolette doppie.

Gli interi e i valori a virgola mobile sono convertiti in stringhe che rappresentano valori numerici. I valori booleani sono convertiti trasformando il valore TRUE nella stringa “1″, mentre FALSE nella stringa vuota (“”). Gli array sono sempre convertiti nel valore della stringa “Array” e gli oggetti nel valore “Object”. Le risorse sono convertite in una stringa come “Resource id #X” in cui X è un identificatore numerico univoco, utilizzato da php per identificare la risorsa. NULL viene convertito nella stringa vuota (“”).

Conversione in array

E’ possibile convertire una variabile o un’espressione in un array tramite anche la funzione array, la stessa utilizzata per creare un nuovo array.

Gli interi, i numeri a virgola mobile, le stringhe, i valori booleani e le risorse sono convertite creando un array con un unico elemento (con indice pari a 0), ossia il valore della variabile o dell’espressione. Gli oggetti vengono convertiti creando un array con le chiavi rappresentate dai nomi delle variabili membro dell’oggetto e con i valori costituiti dal valore delle variabili.

Funzioni utili per la conversione di tipo

is_type

Tutte queste funzioni restituiscono un valore booleano che indica se il valore specificato è o non è del tipo richiesto:

is_integer, is_float, is_numeric (restituisce TRUE se l'argomento è un numero a virgola mobile, un intero o una stringa numerica), is_string, is_bool, is_array, is_object, is_null

gettype

Segnala di quale tipo php considera attualmente una variabile o un’espressione; restituisce:

“boolean”, “integer”, “double”, “string”, “array”, “object”, “resource”, “NULL”, “unknown type”.

settype

Questa funzione richiede di specificare due argomenti: la variabile da convertire e il tipo nel quale deve essere convertita, espresso come una stringa. Restituisce un valore booleano che indica se la conversione è avvenuta con successo o meno.

<?php
    $var = 234.234;
    settype($var, "string");
    //ora $var hai il valore "234.234", del tipo stringa
?>

echo

Mostrare il testo all’utente; quindi anche variabili.

<?php echo "HELLO WORLD"; ?>

N.B. echo non è una funzione PHP, ma è un costrutto, per questo non richede l’uso di parentesi tonde.

var_dump

La funzione var_dump mostra il tipo e il valore di una variabile nello stream dell’output (in realtà è possibile assegnarvi più di una variabile: la funzione elabora il risultato di qualsiasi espressione PHP valida). Nel caso delle stringhe, var_dump restituisce anche il numero di caratteri che compongono la stringa:

<?php
    $randomNum = array(5, 3, 6, 4, 2, 1);
    var_dump($randomNum);
?>

Il codice precedente genera in un browser web il seguente output:

array(6) { [0]=> int(5) [1]=> int(3) [2]=> int(6)
               [3]=> int(4) [4]=> int(2) [5]=> int(1) }

print_r

La funzione print_r è simile a var_dump, ma cerca di rendere leggibile l’output agli utenti. print_r permette anche di specificare un valore facoltativo (chiamato parametro di una funzione) che indica alla funzione di restituire i risultati in una stringa e non di mostrarli nello stream di output.

L’output particolarmente leggibile generato da questa funzione è utile soprattutto per oggetti e array.

<?php
    $drinks = array("Coffee", "Caf&eacute; au Lait", "Mocha", "Espresso", "Americano", "Latte");
    print_r($drinks);
?>

Lo script precedente mostra il seguente output in un browser web:

Array ([0] => Coffee [1] => Café [2] => Mocha
         [3] => Espresso [4] => Americano [5] => Latte )

var_export

L’ultimo di questo gruppo di funzioni utili per la visualizzazione delle variabili e del loro contenuto è la funzione var_export, anch’essa molto simile a var_dump, tranne per il fatto che l’output è costituito da una rappresentazione valida di codice PHP dei valori contenuti nelle variabili fornite come parametro.

Per esempio, il seguente script:

<?php
    $arr = array(1, 2, 3, 4);
    var_export($arr);
?>

produce il seguente output (formattato per una lettura più semplice):

array (
    0 => 1,
    1 => 2,
    2 => 3,
    3 => 4
)