Esercitazioni PHP: esercizi e soluzioni per studio o lavoro

Esercitazione su Fondamenti di PHP

• Sintassi di Base
• Strutture di Controllo
• Funzioni
• Variabili e Tipi di Dati
• Array e Cicli

Esercizio

Creare una funzione in PHP chiamata calcolaSomma, che accetta due parametri numerici e ritorna la loro somma.

Utilizzare la struttura di controllo if all’interno della funzione per verificare che i parametri passati siano effettivamente numeri. Se uno dei due parametri non è un numero, la funzione dovrà ritornare il messaggio “Input non valido“.

Infine, creare un array di numeri e utilizzare un ciclo foreach per sommare tutti gli elementi dell’array utilizzando la funzione creata in precedenza.

Soluzione

<?php
    function calcolaSomma($a, $b) {
        if (is_numeric($a) && is_numeric($b)) {
            return $a + $b;
        } else {
            return "Input non valido";
        }
    }

    $numeri = array(1, 2, 3, 4, 5);
    $somma = 0;
    
    foreach ($numeri as $numero) {
        $somma = calcolaSomma($somma, $numero);
    }

    echo "La somma dei numeri nell'array è: " . $somma;
?>

In questo esercizio:

• Creiamo una funzione calcolaSomma che prende due parametri e, usando una struttura di controllo if, verifica che siano numeri prima di sommarli.
• Creiamo un array $numeri contenente alcuni valori numerici.
• Utilizziamo un ciclo foreach per passare attraverso ogni elemento dell’array $numeri, e sommiamo ogni elemento all’accumulatore $somma usando la funzione calcolaSomma.
• Infine, stampiamo il risultato con echo.

Esercitazione su OOP in PHP

• Creazione di Classi e Oggetti
• Ereditarietà
• Polimorfismo
• Incapsulamento
• Costruttori e Distruttori

Esercizio

Creare una classe chiamata Persona con le seguenti proprietà: nome, cognome, e età.

Implementare un costruttore che prenda tre parametri per inizializzare le proprietà dell’oggetto.

Creare una sottoclasse chiamata Studente che erediti da Persona e abbia una proprietà aggiuntiva: corsoDiStudi.

Implementare il polimorfismo creando un metodo chiamato presentati() in entrambe le classi, che per la Persona restituisce una stringa del tipo “Sono Mario Rossi e ho 35 anni”, mentre per lo Studente “Sono Mario Rossi, ho 20 anni e studio Ingegneria”.

Utilizzare l’incapsulamento per proteggere la proprietà età in modo che possa essere impostata solo attraverso un metodo che preveda il controllo che l’età sia un valore positivo.

Soluzione

<?php
    class Persona {
        protected $nome;
        protected $cognome;
        protected $eta;

        public function __construct($nome, $cognome, $eta) {
            $this->nome = $nome;
            $this->cognome = $cognome;
            $this->setEta($eta);
        }

        protected function setEta($eta) {
            if ($eta > 0) {
                $this->eta = $eta;
            }
        }

        public function presentati() {
            return "Sono " . $this->nome . " " . $this->cognome . " e ho " . $this->eta . " anni";
        }
    }

    class Studente extends Persona {
        private $corsoDiStudi;

        public function __construct($nome, $cognome, $eta, $corsoDiStudi) {
            parent::__construct($nome, $cognome, $eta);
            $this->corsoDiStudi = $corsoDiStudi;
        }

        public function presentati() {
            return "Sono " . $this->nome . " " . $this->cognome . ", ho " . $this->eta . " anni e studio " . $this->corsoDiStudi;
        }
    }

    // Esempio di utilizzo
    $persona = new Persona("Mario", "Rossi", 35);
    echo $persona->presentati();  // Output: Sono Mario Rossi e ho 35 anni

    $studente = new Studente("Luca", "Bianchi", 20, "Ingegneria");
    echo $studente->presentati();  // Output: Sono Luca Bianchi, ho 20 anni e studio Ingegneria
?>

In questo esercizio:

• Creiamo una classe Persona con le proprietà nome, cognome e età, e un costruttore per inizializzarle. La proprietà età è protetta attraverso l’incapsulamento ed è impostata solo attraverso un metodo che controlla che il valore sia positivo.
• Creiamo una sottoclasse Studente che estende Persona e aggiunge una nuova proprietà corsoDiStudi.
• Implementiamo il polimorfismo attraverso il metodo presentati() in entrambe le classi, che restituisce una stringa di presentazione differente per Persona e Studente.
• Infine, presentiamo un esempio di utilizzo delle classi create.

Esercitazione su Interazione con il Database in PHP

• Connessione a MySQL con PDO
• Esecuzione di Query SQL
• Prepared Statements
• CRUD (Create, Read, Update, Delete)

Esercizio

Creare una semplice applicazione PHP per gestire un elenco di studenti in un database. Ogni studente ha un ID, un nome, un cognome e un indirizzo email. L’applicazione deve permettere di:

• Creare un nuovo studente (INSERT)
• Leggere l’elenco degli studenti dal database (SELECT)
• Aggiornare le informazioni di uno studente esistente (UPDATE)
• Eliminare uno studente dal database (DELETE)

Utilizzare PDO per connettersi a un database MySQL e eseguire le query SQL necessarie. Inoltre, assicurarsi di utilizzare Prepared Statements per evitare SQL Injection.

Soluzione

<?php
    try {
        $pdo = new PDO('mysql:host=localhost;dbname=studenti', 'root', 'password');
        $pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
    } catch (PDOException $e) {
        die('Connection failed: ' . $e->getMessage());
    }

    // CREATE
    function createStudent($nome, $cognome, $email) {
        global $pdo;
        $stmt = $pdo->prepare('INSERT INTO studenti (nome, cognome, email) VALUES (:nome, :cognome, :email)');
        $stmt->execute([':nome' => $nome, ':cognome' => $cognome, ':email' => $email]);
    }

    // READ
    function getStudents() {
        global $pdo;
        $stmt = $pdo->query('SELECT * FROM studenti');
        return $stmt->fetchAll(PDO::FETCH_ASSOC);
    }

    // UPDATE
    function updateStudent($id, $nome, $cognome, $email) {
        global $pdo;
        $stmt = $pdo->prepare('UPDATE studenti SET nome = :nome, cognome = :cognome, email = :email WHERE id = :id');
        $stmt->execute([':id' => $id, ':nome' => $nome, ':cognome' => $cognome, ':email' => $email]);
    }

    // DELETE
    function deleteStudent($id) {
        global $pdo;
        $stmt = $pdo->prepare('DELETE FROM studenti WHERE id = :id');
        $stmt->execute([':id' => $id]);
    }

    // Example Usage
    createStudent('Mario', 'Rossi', 'mario.rossi@example.com');
    $students = getStudents();
    updateStudent(1, 'Mario', 'Rossini', 'mario.rossini@example.com');
    deleteStudent(2);
?>

In questa esercitazione:

• Creiamo una connessione al database studenti utilizzando la classe PDO di PHP.
• Definiamo quattro funzioni, una per ogni operazione CRUD:
  • createStudent($nome, $cognome, $email): Inserisce un nuovo studente nel database.
  • getStudents(): Legge e restituisce tutti gli studenti presenti nel database.
  • updateStudent($id, $nome, $cognome, $email): Aggiorna le informazioni di uno studente esistente nel database.
  • deleteStudent($id): Rimuove uno studente dal database.
• Tutte le query SQL sono eseguite utilizzando prepared statements per evitare attacchi di SQL Injection.
• Infine, presentiamo un esempio di utilizzo delle funzioni create.

Esercitazione su Gestione dei Form in PHP

• Creazione di Form HTML
• Gestione dei Dati Inviati via POST o GET
• Validazione dei Dati Inseriti
• Upload di File

Esercizio

Creare un form HTML che permetta all’utente di inserire il proprio nome, cognome, indirizzo email e caricare una foto profilo. Il form deve essere inviato al server utilizzando il metodo POST. Sul server, il codice PHP dovrà:

• Validare che tutti i campi siano stati compilati
• Validare che l’indirizzo email sia in un formato valido
• Validare che il file caricato sia un’immagine e non superi una dimensione di 2MB
• Se tutte le validazioni passano, salvare l’immagine in una cartella e memorizzare i dati dell’utente in un file di testo

Soluzione

<!-- Form HTML -->
<form action="upload.php" method="post" enctype="multipart/form-data">
    Nome: <input type="text" name="nome" /><br>
    Cognome: <input type="text" name="cognome" /><br>
    Email: <input type="email" name="email" /><br>
    Foto Profilo: <input type="file" name="foto" /><br>
    <input type="submit" value="Invia" />
</form>

<?php
// upload.php
if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    $nome = $_POST['nome'];
    $cognome = $_POST['cognome'];
    $email = $_POST['email'];
    $foto = $_FILES['foto'];

    if (empty($nome) || empty($cognome) || empty($email) || empty($foto)) {
        echo "Tutti i campi sono obbligatori.";
    } elseif (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
        echo "Formato email non valido.";
    } elseif ($foto['size'] > 2000000 || !in_array($foto['type'], ['image/jpeg', 'image/png', 'image/gif'])) {
        echo "Il file deve essere un'immagine di dimensioni inferiori a 2MB.";
    } else {
        move_uploaded_file($foto['tmp_name'], 'uploads/' . $foto['name']);
        $data = "Nome: $nome, Cognome: $cognome, Email: $email, Foto: " . $foto['name'] . "\n";
        file_put_contents('utenti.txt', $data, FILE_APPEND);
        echo "Dati salvati correttamente.";
    }
}
?>

In questa esercitazione:

• Creiamo un form HTML con campi per il nome, cognome, indirizzo email e un campo per caricare una foto profilo. Questo form invierà i dati al file upload.php utilizzando il metodo POST.
• Nel file upload.php, il codice PHP riceve i dati inviati via POST e valida che tutti i campi siano stati compilati, che l’indirizzo email sia in un formato valido e che il file caricato sia un’immagine con una dimensione non superiore a 2MB.
• Se tutte le validazioni passano, il file immagine viene salvato in una cartella denominata uploads (è necessario assicurarsi che questa cartella esista e sia scrivibile) e i dati dell’utente vengono memorizzati in un file di testo utenti.txt.
• In caso contrario, viene visualizzato un messaggio di errore appropriato.

Esercitazione su Sessioni e Cookies in PHP

• Inizializzazione di una Sessione
• Creazione e Lettura di Cookies
• Autenticazione Utente

Esercizio

Creare un sistema di autenticazione utente che fa uso di sessioni e cookies.

1. Creare una pagina di login dove l’utente può inserire username e password.
2. Se l’utente è autenticato con successo, inizializzare una sessione e creare un cookie che memorizza il suo username.
3. Se l’utente ritorna al sito e ha il cookie, dovrebbe essere riconosciuto e non necessitare di loggarsi nuovamente.
4. Creare una pagina di logout che distrugge la sessione e cancella il cookie.

Soluzione

<?php
// login.php
session_start();

if (isset($_POST['username']) && isset($_POST['password'])) {
    $username = $_POST['username'];
    $password = $_POST['password'];

    // Simuliamo un controllo con username e password statici
    if ($username == 'admin' && $password == 'admin') {
        $_SESSION['user'] = $username;

        setcookie('username', $username, time() + (86400 * 30), "/");
        header('Location: welcome.php');
    } else {
        echo "<h4>Credenziali non valide</h4>";
    }
}
?>

<!-- Form di login -->
<form action="" method="post">
    Username: <input type="text" name="username" /><br />
    Password: <input type="password" name="password" /><br />
    <input type="submit" value="Login" />
</form>

<?php
// welcome.php
session_start();

if (isset($_SESSION['user']) || isset($_COOKIE['username'])) {
    echo "<h4>Benvenuto, " . (isset($_COOKIE['username']) ? $_COOKIE['username'] : $_SESSION['user']) . "!</h4>";
    echo '<a href="logout.php">Logout</a>';
} else {
    header('Location: login.php');
}
?>

<?php
// logout.php
session_start();

// Distruggi la sessione
session_destroy();

// Cancella il cookie
setcookie('username', '', time() - 3600, '/');

// Reindirizza alla pagina di login
header('Location: login.php');
?>

In questa esercitazione:

• Creiamo una semplice pagina di login con un form per l’inserimento di username e password. Per semplicità, stiamo utilizzando credenziali statiche (‘admin’, ‘admin’) come esempio di verifica.
• Se l’utente viene autenticato con successo, inizializziamo una sessione e creiamo un cookie che memorizza il suo username.
• Creiamo una pagina welcome.php che verifica se l’utente è loggato tramite sessione o cookie. Se lo è, viene mostrato un messaggio di benvenuto; altrimenti, viene reindirizzato alla pagina di login.
• Infine, creiamo una pagina logout.php che distrugge la sessione e cancella il cookie, quindi reindirizza l’utente alla pagina di login.

Esercitazione su File Handling ed Error Handling in PHP

• Lettura e Scrittura di File
• Manipolazione dei File e delle Directory
• Gestione degli Errori

Esercizio

Creare uno script PHP che faccia il seguente:

1. Creare un nuovo file chiamato data.txt se non esiste già.
2. Scrive nel file i dati: “Nome: John, Età: 25”.
3. Legge il file e stampa il contenuto.
4. Rinomina il file in updated_data.txt.
5. Mostra un messaggio di errore personalizzato se il file non può essere letto.

Soluzione

<?php

// Step 1: Creare un nuovo file chiamato "data.txt" se non esiste già.
$filename = "data.txt";
if (!file_exists($filename)) {
    $file = fopen($filename, "w");
    fclose($file);
}

// Step 2: Scrive nel file i dati: "Nome: John, Età: 25".
file_put_contents($filename, "Nome: John, Età: 25");

// Step 3: Legge il file e stampa il contenuto.
if (is_readable($filename)) {
    $content = file_get_contents($filename);
    echo "Contenuto del file: " . $content . "<br>";
} else {
    die("Errore: il file $filename non può essere letto.<br>");
}

// Step 4: Rinomina il file in "updated_data.txt".
$newFilename = "updated_data.txt";
if (rename($filename, $newFilename)) {
    echo "Il file è stato rinominato con successo in $newFilename.<br>";
} else {
    echo "Errore durante il tentativo di rinominare il file.<br>";
}

// Step 5: Mostra un messaggio di errore personalizzato se il file non può essere letto.
set_error_handler(function($errno, $errstr) {
    echo "Errore personalizzato: [$errno] $errstr<br>";
});

// Creiamo un errore per dimostrazione
fopen("file_inesistente.txt", "r");

?>

In questa esercitazione:

• Nello Step 1, lo script verifica se un file chiamato “data.txt” esiste. Se non esiste, lo crea.
• Nello Step 2, lo script scrive la stringa “Nome: John, Età: 25” nel file “data.txt”.
• Nello Step 3, lo script tenta di leggere il contenuto del file “data.txt”. Se il file è leggibile, stampa il contenuto; altrimenti, stampa un messaggio di errore.
• Nello Step 4, lo script rinomina il file “data.txt” in “updated_data.txt“.
• Nello Step 5, definiamo una funzione di gestione degli errori personalizzata con set_error_handler. Per dimostrare questo, abbiamo simulato un errore cercando di aprire un file inesistente, il che attiverà il gestore di errori personalizzato.

Esercitazione su Uso di Composer in PHP

• Installazione di Composer
• Gestione delle Dipendenze
• Autoloading delle Classi

Esercizio

Creare uno script PHP che faccia il seguente:

1. Installare Composer sul proprio sistema se non è già installato.
2. Creare un nuovo progetto PHP e inizializzare Composer.
3. Aggiungere una dipendenza a guzzlehttp/guzzle usando Composer.
4. Utilizzare l’Autoloading di Composer per includere le classi nel tuo progetto.
5. Creare una classe HttpClient che usa Guzzle per fare una semplice richiesta GET a https://jsonplaceholder.typicode.com/posts/1 e stampare la risposta.

Soluzione

Seguire i seguenti passaggi per risolvere l’esercizio:

# Step 1: Installazione di Composer
# Visita il sito ufficiale di Composer per le istruzioni di installazione:
# https://getcomposer.org/download/

# Step 2: Creare un nuovo progetto PHP e inizializzare Composer
mkdir mio_progetto
cd mio_progetto
composer init

# Step 3: Aggiungere una dipendenza a guzzlehttp/guzzle usando Composer
composer require guzzlehttp/guzzle

# Step 4: Utilizzare l'Autoloading di Composer per includere le classi nel tuo progetto
# Composer genera automaticamente il file di autoloading. Dovete solo includerlo nel vostro script PHP:
require 'vendor/autoload.php';

# Step 5: Creare una classe HttpClient che usa Guzzle per fare una semplice richiesta GET

<?php

require 'vendor/autoload.php';

use GuzzleHttp\Client;

class HttpClient {
    private $client;

    public function __construct() {
        $this->client = new Client();
    }

    public function fetchPost($id) {
        $response = $this->client->get("https://jsonplaceholder.typicode.com/posts/{$id}");
        return json_decode($response->getBody(), true);
    }
}

// Uso della classe HttpClient per fare una richiesta GET
$httpClient = new HttpClient();
$post = $httpClient->fetchPost(1);
print_r($post);

?>

In questa soluzione, nello Step 1, l’utente è guidato alla pagina di download di Composer per istruzioni dettagliate.

Da Step 2 a Step 5, abbiamo un esempio concreto che mostra come creare un nuovo progetto PHP, inizializzare Composer, gestire le dipendenze, usare l’autoloading di Composer e creare una semplice classe per effettuare richieste HTTP utilizzando la libreria Guzzle.

Esercitazione su Testing in PHP

• Introduzione a PHPUnit
• Scrittura e Esecuzione di Test Unitari

Esercizio

Creare una classe chiamata Calculator che ha i metodi per addizione, sottrazione, moltiplicazione e divisione. Scrivere test unitari per questa classe utilizzando PHPUnit per assicurarsi che i metodi funzionino come previsto.

1. Installare PHPUnit nel proprio progetto.
2. Creare la classe Calculator con i seguenti metodi: add, subtract, multiply, e divide.
3. Scrivere test unitari per la classe Calculator utilizzando PHPUnit.
4. Eseguire i test unitari e verificare che tutti passino.

Soluzione

Seguire i seguenti passaggi per risolvere l’esercizio:

# Step 1: Installazione di PHPUnit
# Installare PHPUnit tramite Composer:
composer require --dev phpunit/phpunit

# Step 2: Creare la classe Calculator
# Creare un file chiamato Calculator.php e inserire il seguente codice:

<?php

class Calculator {
    public function add($a, $b) {
        return $a + $b;
    }
    
    public function subtract($a, $b) {
        return $a - $b;
    }
    
    public function multiply($a, $b) {
        return $a * $b;
    }
    
    public function divide($a, $b) {
        if ($b == 0) {
            throw new \InvalidArgumentException("Divider cannot be zero");
        }
        return $a / $b;
    }
}

?>

# Step 3: Scrivere test unitari per la classe Calculator
# Creare un file chiamato CalculatorTest.php e inserire il seguente codice:

<?php

use PHPUnit\Framework\TestCase;

class CalculatorTest extends TestCase {
    public function testAdd() {
        $calculator = new Calculator();
        $this->assertEquals(5, $calculator->add(2, 3));
    }
    
    public function testSubtract() {
        $calculator = new Calculator();
        $this->assertEquals(1, $calculator->subtract(3, 2));
    }
    
    public function testMultiply() {
        $calculator = new Calculator();
        $this->assertEquals(6, $calculator->multiply(2, 3));
    }
    
    public function testDivide() {
        $calculator = new Calculator();
        $this->assertEquals(2, $calculator->divide(6, 3));
    }
    
    public function testDivideByZero() {
        $this->expectException(\InvalidArgumentException::class);
        $calculator = new Calculator();
        $calculator->divide(6, 0);
    }
}

?>

# Step 4: Eseguire i test unitari e verificare che tutti passino
# Dal terminale, eseguire il seguente comando:

./vendor/bin/phpunit CalculatorTest.php

In questa soluzione:

• Nello Step 1, viene fornito il comando per installare PHPUnit tramite Composer.

• Nello Step 2, è mostrata la creazione della classe Calculator con metodi per addizione, sottrazione, moltiplicazione e divisione.

• Nello Step 3, viene creata una classe di test CalculatorTest che estende la classe base TestCase di PHPUnit, e vengono scritti vari test per la classe Calculator.

• Nello Step 4, viene fornito il comando per eseguire i test unitari attraverso PHPUnit e verificare che tutti passino.