Esercitazioni PHP: esercizi e soluzioni per studio o lavoro

Foto dell'autore

Andrea Barbieri

 

Home > News feed > Lavorare nel settore > 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 messaggioInput 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.

Lascia un commento

Panoramica privacy
Multinazionali Tech

Questo sito web utilizza i cookie per consentirci di fornirti la migliore esperienza utente possibile. Le informazioni sui cookie vengono memorizzate nel tuo browser ed eseguono funzioni come riconoscerti quando ritorni sul nostro sito Web e aiutare il nostro team a capire quali sezioni del sito Web trovi più interessanti e utili. Maggiori informazioni qui

Cookie strettamente necessari

I cookie strettamente necessari dovrebbero essere sempre attivati per poter salvare le tue preferenze per le impostazioni dei cookie.

Cookie di terze parti

Questo sito Web utilizza Google Analytics per raccogliere informazioni anonime come il numero di visitatori del sito e le pagine più popolari.

Mantenere questo cookie abilitato ci aiuta a migliorare il nostro sito Web.