PHP: guida completa dai fondamenti allo sviluppo web avanzato

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# Ubuntu/Debian
sudo apt update
sudo apt install apache2 mysql-server php libapache2-mod-php php-mysql

# Avviare servizi
sudo systemctl start apache2
sudo systemctl start mysql

# Testare installazione
echo "<?php phpinfo(); ?>" | sudo tee /var/www/html/info.php

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

# docker-compose.yml
version: '3.8'
services:
  web:
    image: php:8.2-apache
    ports:
      - "8080:80"
    volumes:
      - ./src:/var/www/html

  db:
    image: mysql:8.0
    environment:
      MYSQL_ROOT_PASSWORD: rootpass
      MYSQL_DATABASE: testdb
    ports:
      - "3306:3306"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

<?php
// Primo script PHP
echo "Ciao, mondo!";

// Questo è un commento
/*
   Commento
   multi-linea
*/

// Informazioni sul PHP
phpinfo();
?>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

<?php
// I tag PHP iniziano sempre con <?php

// Variabili (iniziano con $)
$nome = "Gianluca";
$età = 30;
$altezza = 1.75;
$isStudent = true;

// Output
echo "Mi chiamo $nome e ho $età anni<br>";
echo 'Altezza: ' . $altezza . 'm<br>';
print("Studente: " . ($isStudent ? "Sì" : "No"));

// Fine tag PHP (opzionale se il file è solo PHP)
?>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

<?php
// Scalari
$integer = 42;
$float = 3.14159;
$string = "Ciao mondo";
$boolean = true;

// Composti
$array = [1, 2, 3, 4, 5];
$object = new stdClass();

// Speciali
$null_var = null;
$resource = fopen('file.txt', 'r');

// Controllo del tipo
var_dump($integer);
echo gettype($string);

// Conversioni di tipo
$num_string = "123";
$number = (int)$num_string;     // Cast esplicito
$auto_number = $num_string + 0; // Conversione automatica
?>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

<?php
$a = 10;
$b = 3;

// Aritmetici
echo $a + $b;  // 13 - Addizione
echo $a - $b;  // 7  - Sottrazione
echo $a * $b;  // 30 - Moltiplicazione
echo $a / $b;  // 3.333... - Divisione
echo $a % $b;  // 1  - Modulo
echo $a ** $b; // 1000 - Esponenziazione (PHP 5.6+)

// Assegnazione
$c = $a;       // Assegnazione semplice
$c += $b;      // $c = $c + $b
$c -= $b;      // $c = $c - $b
$c .= " testo"; // Concatenazione

// Confronto
var_dump($a == $b);   // false - Uguaglianza
var_dump($a === $b);  // false - Identità (tipo e valore)
var_dump($a != $b);   // true  - Disuguaglianza
var_dump($a !== $b);  // true  - Non identità
var_dump($a <=> $b);  // 1     - Spaceship operator (PHP 7+)

// Logici
$x = true;
$y = false;
var_dump($x && $y);   // false - AND
var_dump($x || $y);   // true  - OR
var_dump(!$x);        // false - NOT

// Incremento/Decremento
echo ++$a;  // Pre-incremento
echo $a++;  // Post-incremento
echo --$b;  // Pre-decremento
echo $b--;  // Post-decremento
?>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

<?php
// Definire costanti
define('PI', 3.14159);
const GRAVITY = 9.8;

// Costanti magiche
echo __FILE__;      // Percorso completo del file
echo __LINE__;      // Numero di linea corrente
echo __FUNCTION__; // Nome della funzione corrente
echo __CLASS__;    // Nome della classe corrente
echo __METHOD__;   // Nome del metodo corrente

// Usare costanti
echo "Il valore di PI è: " . PI;
echo "La gravità è: " . GRAVITY . " m/s²";
?>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

<?php
$voto = 85;

// if-elseif-else
if ($voto >= 90) {
    $giudizio = "Eccellente";
} elseif ($voto >= 80) {
    $giudizio = "Buono";
} elseif ($voto >= 60) {
    $giudizio = "Sufficiente";
} else {
    $giudizio = "Insufficiente";
}

echo "Voto: $voto - Giudizio: $giudizio<br>";

// Operatore ternario
$status = ($voto >= 60) ? "Promosso" : "Bocciato";
echo "Status: $status<br>";

// Null coalescing operator (PHP 7+)
$nome = $_GET['nome'] ?? 'Guest';
echo "Benvenuto, $nome!<br>";

// Switch
$giorno = 3;
switch ($giorno) {
    case 1:
        echo "Lunedì";
        break;
    case 2:
        echo "Martedì";
        break;
    case 3:
        echo "Mercoledì";
        break;
    default:
        echo "Giorno non valido";
        break;
}
?>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

<?php
// For loop
echo "<h3>Tabellina del 5:</h3>";
for ($i = 1; $i <= 10; $i++) {
    echo "5 x $i = " . (5 * $i) . "<br>";
}

// While loop
echo "<h3>Conto alla rovescia:</h3>";
$countdown = 5;
while ($countdown > 0) {
    echo "$countdown...<br>";
    $countdown--;
}
echo "Via!<br>";

// Do-while loop
echo "<h3>Numero casuale:</h3>";
do {
    $numero = rand(1, 10);
    echo "Numero generato: $numero<br>";
} while ($numero != 7);

// Foreach (per array)
$frutti = ['mela', 'banana', 'arancia', 'kiwi'];
echo "<h3>Lista frutti:</h3>";
foreach ($frutti as $frutto) {
    echo "- $frutto<br>";
}

// Foreach con chiave e valore
$persona = [
    'nome' => 'Mario',
    'cognome' => 'Rossi',
    'età' => 30,
    'città' => 'Roma'
];

echo "<h3>Informazioni persona:</h3>";
foreach ($persona as $campo => $valore) {
    echo "$campo: $valore<br>";
}

// Controllo del flusso nei cicli
echo "<h3>Numeri pari da 1 a 20:</h3>";
for ($i = 1; $i <= 20; $i++) {
    if ($i % 2 != 0) {
        continue; // Salta i numeri dispari
    }

    if ($i > 15) {
        break; // Interrompe il ciclo
    }

    echo "$i ";
}
?>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

<?php
// Funzione semplice
function saluta() {
    return "Ciao!";
}

echo saluta(); // Output: Ciao!

// Funzione con parametri
function salutaPersona($nome, $cognome = "Sconosciuto") {
    return "Ciao, $nome $cognome!";
}

echo salutaPersona("Mario"); // Output: Ciao, Mario Sconosciuto!
echo salutaPersona("Mario", "Rossi"); // Output: Ciao, Mario Rossi!

// Funzione con parametri variabili
function somma(...$numeri) {
    $totale = 0;
    foreach ($numeri as $numero) {
        $totale += $numero;
    }
    return $totale;
}

echo somma(1, 2, 3, 4, 5); // Output: 15

// Funzione con tipo di ritorno (PHP 7+)
function calcola_area_cerchio(float $raggio): float {
    return 3.14159 * $raggio * $raggio;
}

echo calcola_area_cerchio(5.0); // Output: 78.53975

// Funzioni anonime (Closure)
$quadrato = function($x) {
    return $x * $x;
};

echo $quadrato(4); // Output: 16

// Arrow functions (PHP 7.4+)
$cubo = fn($x) => $x * $x * $x;
echo $cubo(3); // Output: 27
?>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

<?php
$globale = "Sono globale";

function testScope() {
    global $globale;
    $locale = "Sono locale";
    static $statica = 0;

    $statica++;
    echo "Globale: $globale<br>";
    echo "Locale: $locale<br>";
    echo "Statica: $statica<br>";
}

testScope(); // Statica: 1
testScope(); // Statica: 2
?>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

<?php
// Array indicizzati
$frutti = array('mela', 'banana', 'arancia');
$numeri = [1, 2, 3, 4, 5]; // Sintassi short (PHP 5.4+)

echo $frutti[0]; // Output: mela

// Array associativi
$persona = [
    'nome' => 'Mario',
    'età' => 30,
    'città' => 'Roma'
];

echo $persona['nome']; // Output: Mario

// Array multidimensionali
$studenti = [
    ['nome' => 'Mario', 'voto' => 85],
    ['nome' => 'Anna', 'voto' => 92],
    ['nome' => 'Luigi', 'voto' => 78]
];

echo $studenti[1]['nome']; // Output: Anna

// Funzioni per array
$numeri = [3, 1, 4, 1, 5, 9, 2, 6];

// Ordinamento
sort($numeri);          // Ordina crescente
rsort($numeri);         // Ordina decrescente
asort($persona);        // Ordina mantenendo chiavi
ksort($persona);        // Ordina per chiavi

// Ricerca e filtri
$cercato = array_search(4, $numeri);
$filtrati = array_filter($numeri, function($n) {
    return $n > 5;
});

// Trasformazioni
$quadrati = array_map(function($n) {
    return $n * $n;
}, $numeri);

// Riduzione
$somma = array_reduce($numeri, function($carry, $item) {
    return $carry + $item;
}, 0);

// Utility
echo count($numeri);           // Conta elementi
echo in_array(5, $numeri);     // Verifica presenza
$keys = array_keys($persona);  // Ottiene chiavi
$values = array_values($persona); // Ottiene valori

print_r($numeri); // Debug array
?>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

<?php
$testo = "PHP è fantastico!";

// Informazioni sulla stringa
echo strlen($testo);        // Lunghezza: 18
echo str_word_count($testo); // Numero parole: 3

// Ricerca e sostituzione
$posizione = strpos($testo, "PHP");     // Trova posizione: 0
$sostituito = str_replace("PHP", "JavaScript", $testo);

// Maiuscole e minuscole
echo strtoupper($testo);    // PHP È FANTASTICO!
echo strtolower($testo);    // php è fantastico!
echo ucfirst($testo);       // Php è fantastico!
echo ucwords($testo);       // Php È Fantastico!

// Tagliare e estrarre
echo substr($testo, 0, 3);  // PHP
echo substr($testo, -11);   // fantastico!

// Dividere e unire
$parole = explode(" ", $testo);     // ['PHP', 'è', 'fantastico!']
$ricostruito = implode("-", $parole); // PHP-è-fantastico!

// Pulizia
$sporco = "  Testo con spazi  ";
echo trim($sporco);         // "Testo con spazi"
echo ltrim($sporco);        // "Testo con spazi  "
echo rtrim($sporco);        // "  Testo con spazi"

// Escape e validazione
$pericoloso = "<script>alert('xss')</script>";
echo htmlspecialchars($pericoloso); // &lt;script&gt;alert('xss')&lt;/script&gt;

// Espressioni regolari
$email = "test@example.com";
if (preg_match("/^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/", $email)) {
    echo "Email valida";
}

// Formattazione
$prezzo = 1234.56;
echo number_format($prezzo, 2, ',', '.'); // 1.234,56

$data = date('d/m/Y H:i:s');
echo "Oggi è: $data";
?>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

<?php
// Definizione di una classe
class Persona {
    // Proprietà (attributi)
    private $nome;
    private $cognome;
    protected $età;
    public $email;

    // Costanti di classe
    const MAGGIORE_ETA = 18;

    // Costruttore
    public function __construct($nome, $cognome, $età = 0) {
        $this->nome = $nome;
        $this->cognome = $cognome;
        $this->età = $età;
    }

    // Metodi getter e setter
    public function getNome() {
        return $this->nome;
    }

    public function setNome($nome) {
        $this->nome = $nome;
    }

    public function getCognome() {
        return $this->cognome;
    }

    public function getEtà() {
        return $this->età;
    }

    public function setEtà($età) {
        if ($età >= 0 && $età <= 150) {
            $this->età = $età;
        } else {
            throw new InvalidArgumentException("Età non valida");
        }
    }

    // Metodo pubblico
    public function nomeCompleto() {
        return $this->nome . " " . $this->cognome;
    }

    public function èMaggiorenne() {
        return $this->età >= self::MAGGIORE_ETA;
    }

    // Metodo magico per la rappresentazione stringa
    public function __toString() {
        return $this->nomeCompleto() . " (" . $this->età . " anni)";
    }

    // Distruttore
    public function __destruct() {
        // Codice di cleanup se necessario
    }
}

// Creare oggetti
$persona1 = new Persona("Mario", "Rossi", 30);
$persona2 = new Persona("Anna", "Verdi", 25);

// Usare i metodi
echo $persona1->nomeCompleto(); // Mario Rossi
echo $persona1; // Mario Rossi (30 anni) - chiama __toString()

// Proprietà pubbliche
$persona1->email = "mario@email.com";
echo $persona1->email;

// Costanti di classe
echo Persona::MAGGIORE_ETA; // 18
?>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

<?php
// Classe base
class Animale {
    protected $nome;
    protected $specie;

    public function __construct($nome, $specie) {
        $this->nome = $nome;
        $this->specie = $specie;
    }

    public function dormi() {
        return $this->nome . " sta dormendo";
    }

    public function mangia($cibo) {
        return $this->nome . " sta mangiando " . $cibo;
    }

    // Metodo che può essere sovrascritto
    public function versoCaratteristico() {
        return $this->nome . " fa un verso";
    }
}

// Classe derivata
class Cane extends Animale {
    private $razza;

    public function __construct($nome, $razza) {
        parent::__construct($nome, "Cane"); // Chiama costruttore padre
        $this->razza = $razza;
    }

    // Override del metodo padre
    public function versoCaratteristico() {
        return $this->nome . " abbaia: Bau bau!";
    }

    // Metodo specifico della classe
    public function riporta() {
        return $this->nome . " riporta la pallina";
    }

    public function getRazza() {
        return $this->razza;
    }
}

class Gatto extends Animale {
    public function __construct($nome) {
        parent::__construct($nome, "Gatto");
    }

    public function versoCaratteristico() {
        return $this->nome . " miagola: Miau!";
    }

    public function graffia() {
        return $this->nome . " sta graffiando";
    }
}

// Utilizzo
$cane = new Cane("Buddy", "Golden Retriever");
$gatto = new Gatto("Whiskers");

echo $cane->versoCaratteristico(); // Buddy abbaia: Bau bau!
echo $gatto->versoCaratteristico(); // Whiskers miagola: Miau!
echo $cane->riporta(); // Buddy riporta la pallina
?>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

<?php
// Classe astratta
abstract class Veicolo {
    protected $marca;
    protected $modello;

    public function __construct($marca, $modello) {
        $this->marca = $marca;
        $this->modello = $modello;
    }

    // Metodo concreto
    public function getInfo() {
        return $this->marca . " " . $this->modello;
    }

    // Metodo astratto - deve essere implementato dalle classi figlie
    abstract public function avvia();
    abstract public function ferma();
}

// Interface
interface Volabile {
    public function decolla();
    public function atterra();
}

interface Galleggiabile {
    public function naviga();
}

// Implementazione
class Auto extends Veicolo {
    private $carburante;

    public function __construct($marca, $modello, $carburante) {
        parent::__construct($marca, $modello);
        $this->carburante = $carburante;
    }

    public function avvia() {
        return "L'auto " . $this->getInfo() . " è in moto";
    }

    public function ferma() {
        return "L'auto " . $this->getInfo() . " è ferma";
    }
}

class Aereo extends Veicolo implements Volabile {
    public function avvia() {
        return "L'aereo " . $this->getInfo() . " ha acceso i motori";
    }

    public function ferma() {
        return "L'aereo " . $this->getInfo() . " ha spento i motori";
    }

    public function decolla() {
        return "L'aereo " . $this->getInfo() . " sta decollando";
    }

    public function atterra() {
        return "L'aereo " . $this->getInfo() . " sta atterrando";
    }
}

// Utilizzo
$auto = new Auto("Fiat", "500", "Benzina");
$aereo = new Aereo("Boeing", "747");

echo $auto->avvia();
echo $aereo->decolla();
?>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

<?php
namespace App\Models;

// Trait per funzionalità condivise
trait Timestampable {
    private $created_at;
    private $updated_at;

    public function setCreatedAt($datetime) {
        $this->created_at = $datetime;
    }

    public function setUpdatedAt($datetime) {
        $this->updated_at = $datetime;
    }

    public function touch() {
        $this->updated_at = date('Y-m-d H:i:s');
    }
}

trait Sluggable {
    public function generateSlug($text) {
        return strtolower(trim(preg_replace('/[^A-Za-z0-9-]+/', '-', $text)));
    }
}

// Classe che usa i trait
class Article {
    use Timestampable, Sluggable;

    private $title;
    private $content;
    private $slug;

    public function __construct($title, $content) {
        $this->title = $title;
        $this->content = $content;
        $this->slug = $this->generateSlug($title);
        $this->setCreatedAt(date('Y-m-d H:i:s'));
        $this->setUpdatedAt(date('Y-m-d H:i:s'));
    }

    public function getTitle() {
        return $this->title;
    }

    public function getSlug() {
        return $this->slug;
    }
}

// Utilizzo
$article = new Article("La Guida Completa a PHP", "Contenuto dell'articolo...");
echo $article->getSlug(); // la-guida-completa-a-php
?>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

<?php
// Parametri di connessione
$host = 'localhost';
$username = 'root';
$password = '';
$database = 'test_db';

// Connessione procedurale
$connection = mysqli_connect($host, $username, $password, $database);

if (!$connection) {
    die("Connessione fallita: " . mysqli_connect_error());
}

// Query di selezione
$query = "SELECT id, nome, email FROM utenti";
$result = mysqli_query($connection, $query);

if (mysqli_num_rows($result) > 0) {
    echo "<table border='1'>";
    echo "<tr><th>ID</th><th>Nome</th><th>Email</th></tr>";

    while ($row = mysqli_fetch_assoc($result)) {
        echo "<tr>";
        echo "<td>" . $row['id'] . "</td>";
        echo "<td>" . $row['nome'] . "</td>";
        echo "<td>" . $row['email'] . "</td>";
        echo "</tr>";
    }
    echo "</table>";
} else {
    echo "Nessun risultato trovato";
}

// Chiudere connessione
mysqli_close($connection);
?>

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102

<?php
class DatabaseManager {
    private $pdo;

    public function __construct($host, $dbname, $username, $password) {
        try {
            $dsn = "mysql:host=$host;dbname=$dbname;charset=utf8mb4";
            $options = [
                PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,
                PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
                PDO::ATTR_EMULATE_PREPARES => false,
            ];

            $this->pdo = new PDO($dsn, $username, $password, $options);
        } catch (PDOException $e) {
            throw new Exception("Errore di connessione: " . $e->getMessage());
        }
    }

    // INSERT
    public function insertUser($nome, $email, $password) {
        $sql = "INSERT INTO utenti (nome, email, password) VALUES (?, ?, ?)";
        $stmt = $this->pdo->prepare($sql);

        $hashed_password = password_hash($password, PASSWORD_DEFAULT);

        return $stmt->execute([$nome, $email, $hashed_password]);
    }

    // SELECT
    public function getUserById($id) {
        $sql = "SELECT * FROM utenti WHERE id = ?";
        $stmt = $this->pdo->prepare($sql);
        $stmt->execute([$id]);

        return $stmt->fetch();
    }

    public function getAllUsers() {
        $sql = "SELECT id, nome, email, created_at FROM utenti ORDER BY nome";
        $stmt = $this->pdo->query($sql);

        return $stmt->fetchAll();
    }

    // UPDATE
    public function updateUser($id, $nome, $email) {
        $sql = "UPDATE utenti SET nome = ?, email = ? WHERE id = ?";
        $stmt = $this->pdo->prepare($sql);

        return $stmt->execute([$nome, $email, $id]);
    }

    // DELETE
    public function deleteUser($id) {
        $sql = "DELETE FROM utenti WHERE id = ?";
        $stmt = $this->pdo->prepare($sql);

        return $stmt->execute([$id]);
    }

    // Transazioni
    public function transferFunds($from_account, $to_account, $amount) {
        try {
            $this->pdo->beginTransaction();

            // Debita dal conto di partenza
            $sql1 = "UPDATE conti SET saldo = saldo - ? WHERE id = ?";
            $stmt1 = $this->pdo->prepare($sql1);
            $stmt1->execute([$amount, $from_account]);

            // Accredita al conto di destinazione
            $sql2 = "UPDATE conti SET saldo = saldo + ? WHERE id = ?";
            $stmt2 = $this->pdo->prepare($sql2);
            $stmt2->execute([$amount, $to_account]);

            $this->pdo->commit();
            return true;
        } catch (Exception $e) {
            $this->pdo->rollBack();
            throw $e;
        }
    }
}

// Utilizzo
try {
    $db = new DatabaseManager('localhost', 'test_db', 'root', '');

    // Inserire nuovo utente
    $db->insertUser('Mario Rossi', 'mario@email.com', 'password123');

    // Ottenere tutti gli utenti
    $users = $db->getAllUsers();
    foreach ($users as $user) {
        echo $user['nome'] . " - " . $user['email'] . "<br>";
    }

} catch (Exception $e) {
    echo "Errore: " . $e->getMessage();
}
?>

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145

<?php
// form.html
?>
<!DOCTYPE html>
<html>
<head>
    <title>Form di Registrazione</title>
</head>
<body>
    <form action="process_form.php" method="POST">
        <label for="nome">Nome:</label>
        <input type="text" id="nome" name="nome" required><br><br>

        <label for="email">Email:</label>
        <input type="email" id="email" name="email" required><br><br>

        <label for="password">Password:</label>
        <input type="password" id="password" name="password" required><br><br>

        <label for="età">Età:</label>
        <input type="number" id="età" name="età" min="18" max="100"><br><br>

        <label for="bio">Biografia:</label>
        <textarea id="bio" name="bio" rows="4" cols="50"></textarea><br><br>

        <input type="submit" value="Registrati">
    </form>
</body>
</html>

<?php
// process_form.php
class FormValidator {
    private $errors = [];

    public function validateName($name) {
        if (empty(trim($name))) {
            $this->errors['nome'] = "Il nome è obbligatorio";
            return false;
        }

        if (strlen($name) < 2) {
            $this->errors['nome'] = "Il nome deve avere almeno 2 caratteri";
            return false;
        }

        return true;
    }

    public function validateEmail($email) {
        if (empty($email)) {
            $this->errors['email'] = "L'email è obbligatoria";
            return false;
        }

        if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
            $this->errors['email'] = "Formato email non valido";
            return false;
        }

        return true;
    }

    public function validatePassword($password) {
        if (empty($password)) {
            $this->errors['password'] = "La password è obbligatoria";
            return false;
        }

        if (strlen($password) < 8) {
            $this->errors['password'] = "La password deve avere almeno 8 caratteri";
            return false;
        }

        if (!preg_match('/^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)/', $password)) {
            $this->errors['password'] = "La password deve contenere almeno una minuscola, una maiuscola e un numero";
            return false;
        }

        return true;
    }

    public function validateAge($age) {
        if (!empty($age)) {
            if (!is_numeric($age) || $age < 18 || $age > 100) {
                $this->errors['età'] = "L'età deve essere compresa tra 18 e 100 anni";
                return false;
            }
        }

        return true;
    }

    public function getErrors() {
        return $this->errors;
    }

    public function hasErrors() {
        return !empty($this->errors);
    }
}

// Processare il form
if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    $validator = new FormValidator();

    // Sanitize input
    $nome = htmlspecialchars(trim($_POST['nome'] ?? ''));
    $email = filter_var($_POST['email'] ?? '', FILTER_SANITIZE_EMAIL);
    $password = $_POST['password'] ?? '';
    $età = filter_var($_POST['età'] ?? '', FILTER_SANITIZE_NUMBER_INT);
    $bio = htmlspecialchars(trim($_POST['bio'] ?? ''));

    // Validazione
    $validator->validateName($nome);
    $validator->validateEmail($email);
    $validator->validatePassword($password);
    $validator->validateAge($età);

    if ($validator->hasErrors()) {
        // Mostra errori
        echo "<h2>Errori di validazione:</h2>";
        foreach ($validator->getErrors() as $field => $error) {
            echo "<p><strong>$field:</strong> $error</p>";
        }
        echo '<a href="form.html">Torna al form</a>';
    } else {
        // Salva nel database
        try {
            $db = new DatabaseManager('localhost', 'test_db', 'root', '');
            $success = $db->insertUser($nome, $email, $password);

            if ($success) {
                echo "<h2>Registrazione completata con successo!</h2>";
                echo "<p>Benvenuto, $nome!</p>";
            } else {
                echo "<h2>Errore durante la registrazione</h2>";
            }
        } catch (Exception $e) {
            echo "<h2>Errore del database:</h2>";
            echo "<p>" . $e->getMessage() . "</p>";
        }
    }
}
?>

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103

<?php
class FileUploader {
    private $upload_dir = 'uploads/';
    private $allowed_types = ['image/jpeg', 'image/png', 'image/gif'];
    private $max_size = 5242880; // 5MB in bytes

    public function __construct($upload_dir = null) {
        if ($upload_dir) {
            $this->upload_dir = $upload_dir;
        }

        // Crea directory se non esiste
        if (!is_dir($this->upload_dir)) {
            mkdir($this->upload_dir, 0755, true);
        }
    }

    public function upload($file_input_name) {
        // Verifica se il file è stato caricato
        if (!isset($_FILES[$file_input_name]) || $_FILES[$file_input_name]['error'] !== UPLOAD_ERR_OK) {
            throw new Exception('Errore durante il caricamento del file');
        }

        $file = $_FILES[$file_input_name];

        // Validazioni
        $this->validateFile($file);

        // Genera nome file sicuro
        $extension = pathinfo($file['name'], PATHINFO_EXTENSION);
        $filename = uniqid() . '_' . time() . '.' . $extension;
        $filepath = $this->upload_dir . $filename;

        // Sposta il file
        if (!move_uploaded_file($file['tmp_name'], $filepath)) {
            throw new Exception('Impossibile spostare il file caricato');
        }

        return [
            'filename' => $filename,
            'filepath' => $filepath,
            'original_name' => $file['name'],
            'size' => $file['size']
        ];
    }

    private function validateFile($file) {
        // Controlla dimensione
        if ($file['size'] > $this->max_size) {
            throw new Exception('Il file è troppo grande. Dimensione massima: ' . ($this->max_size / 1024 / 1024) . 'MB');
        }

        // Controlla tipo MIME
        if (!in_array($file['type'], $this->allowed_types)) {
            throw new Exception('Tipo di file non consentito. Tipi consentiti: ' . implode(', ', $this->allowed_types));
        }

        // Controllo aggiuntivo del tipo file
        $finfo = finfo_open(FILEINFO_MIME_TYPE);
        $mime_type = finfo_file($finfo, $file['tmp_name']);
        finfo_close($finfo);

        if (!in_array($mime_type, $this->allowed_types)) {
            throw new Exception('Tipo di file non valido');
        }
    }
}

// Form HTML per upload
?>
<!DOCTYPE html>
<html>
<head>
    <title>Upload File</title>
</head>
<body>
    <form action="" method="POST" enctype="multipart/form-data">
        <label for="image">Seleziona immagine:</label>
        <input type="file" id="image" name="image" accept="image/*" required><br><br>

        <input type="submit" name="upload" value="Carica File">
    </form>
</body>
</html>

<?php
// Processare upload
if (isset($_POST['upload'])) {
    try {
        $uploader = new FileUploader();
        $result = $uploader->upload('image');

        echo "<h2>File caricato con successo!</h2>";
        echo "<p><strong>Nome file:</strong> " . $result['filename'] . "</p>";
        echo "<p><strong>Dimensione:</strong> " . number_format($result['size'] / 1024, 2) . " KB</p>";
        echo "<img src='" . $result['filepath'] . "' alt='Uploaded image' style='max-width: 300px;'>";

    } catch (Exception $e) {
        echo "<h2>Errore:</h2>";
        echo "<p>" . $e->getMessage() . "</p>";
    }
}
?>

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

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

class SessionManager {
    public static function login($user_id, $username, $role = 'user') {
        // Rigenera ID sessione per sicurezza
        session_regenerate_id(true);

        $_SESSION['user_id'] = $user_id;
        $_SESSION['username'] = $username;
        $_SESSION['role'] = $role;
        $_SESSION['login_time'] = time();
        $_SESSION['last_activity'] = time();

        return true;
    }

    public static function logout() {
        // Rimuovi tutte le variabili di sessione
        session_unset();

        // Distruggi la sessione
        session_destroy();

        // Rimuovi il cookie di sessione
        if (isset($_COOKIE[session_name()])) {
            setcookie(session_name(), '', time() - 3600, '/');
        }

        return true;
    }

    public static function isLoggedIn() {
        return isset($_SESSION['user_id']);
    }

    public static function requireLogin() {
        if (!self::isLoggedIn()) {
            header('Location: login.php');
            exit;
        }

        // Aggiorna ultima attività
        $_SESSION['last_activity'] = time();
    }

    public static function checkTimeout($timeout = 1800) { // 30 minuti
        if (isset($_SESSION['last_activity'])) {
            if (time() - $_SESSION['last_activity'] > $timeout) {
                self::logout();
                return false;
            }
        }

        return true;
    }

    public static function getUserId() {
        return $_SESSION['user_id'] ?? null;
    }

    public static function getUsername() {
        return $_SESSION['username'] ?? null;
    }

    public static function hasRole($required_role) {
        $user_role = $_SESSION['role'] ?? 'guest';
        return $user_role === $required_role || $user_role === 'admin';
    }
}

// Form di login
if ($_SERVER['REQUEST_METHOD'] === 'POST') {
    $username = $_POST['username'] ?? '';
    $password = $_POST['password'] ?? '';

    // Validazione credenziali (esempio semplificato)
    if ($username === 'admin' && $password === 'password123') {
        SessionManager::login(1, $username, 'admin');
        header('Location: dashboard.php');
        exit;
    } else {
        $error = "Credenziali non valide";
    }
}
?>

<!DOCTYPE html>
<html>
<head>
    <title>Login</title>
</head>
<body>
    <h2>Login</h2>

    <?php if (isset($error)): ?>
        <p style="color: red;"><?php echo $error; ?></p>
    <?php endif; ?>

    <form method="POST">
        <label for="username">Username:</label>
        <input type="text" id="username" name="username" required><br><br>

        <label for="password">Password:</label>
        <input type="password" id="password" name="password" required><br><br>

        <input type="submit" value="Login">
    </form>
</body>
</html>

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

SessionManager::requireLogin();
SessionManager::checkTimeout();

echo "<h1>Benvenuto, " . SessionManager::getUsername() . "!</h1>";
echo "<p>User ID: " . SessionManager::getUserId() . "</p>";
echo "<a href='logout.php'>Logout</a>";
?>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

<?php
class CookieManager {
    public static function set($name, $value, $days = 30, $secure = false, $httponly = true) {
        $expire = time() + ($days * 24 * 60 * 60);

        return setcookie(
            $name,
            $value,
            $expire,
            '/',
            '',
            $secure,
            $httponly
        );
    }

    public static function get($name, $default = null) {
        return $_COOKIE[$name] ?? $default;
    }

    public static function delete($name) {
        if (isset($_COOKIE[$name])) {
            setcookie($name, '', time() - 3600, '/');
            unset($_COOKIE[$name]);
        }
    }

    public static function exists($name) {
        return isset($_COOKIE[$name]);
    }
}

// Esempio: Sistema "Ricordami"
if ($_POST['remember_me'] ?? false) {
    // Genera token sicuro
    $token = bin2hex(random_bytes(32));

    // Salva token nel database associato all'utente
    $db->saveRememberToken($user_id, $token);

    // Imposta cookie
    CookieManager::set('remember_token', $token, 30, true, true);
}

// Controllo token di ricordo
if (!SessionManager::isLoggedIn() && CookieManager::exists('remember_token')) {
    $token = CookieManager::get('remember_token');
    $user = $db->getUserByRememberToken($token);

    if ($user) {
        SessionManager::login($user['id'], $user['username'], $user['role']);

        // Rigenera token per sicurezza
        $new_token = bin2hex(random_bytes(32));
        $db->updateRememberToken($user['id'], $new_token);
        CookieManager::set('remember_token', $new_token, 30, true, true);
    }
}

// Preferences utente
class UserPreferences {
    public static function setTheme($theme) {
        CookieManager::set('user_theme', $theme, 365);
    }

    public static function getTheme() {
        return CookieManager::get('user_theme', 'light');
    }

    public static function setLanguage($language) {
        CookieManager::set('user_language', $language, 365);
    }

    public static function getLanguage() {
        return CookieManager::get('user_language', 'it');
    }
}

// Utilizzo
$theme = UserPreferences::getTheme();
echo "<body class='theme-$theme'>";
?>

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186

<?php
class FileManager {
    public static function read($filepath) {
        if (!file_exists($filepath)) {
            throw new Exception("File non trovato: $filepath");
        }

        $content = file_get_contents($filepath);
        if ($content === false) {
            throw new Exception("Impossibile leggere il file: $filepath");
        }

        return $content;
    }

    public static function write($filepath, $content, $append = false) {
        $flags = $append ? FILE_APPEND | LOCK_EX : LOCK_EX;

        $result = file_put_contents($filepath, $content, $flags);
        if ($result === false) {
            throw new Exception("Impossibile scrivere il file: $filepath");
        }

        return $result;
    }

    public static function readLines($filepath) {
        if (!file_exists($filepath)) {
            throw new Exception("File non trovato: $filepath");
        }

        return file($filepath, FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES);
    }

    public static function copy($source, $destination) {
        if (!file_exists($source)) {
            throw new Exception("File sorgente non trovato: $source");
        }

        if (!copy($source, $destination)) {
            throw new Exception("Impossibile copiare il file");
        }

        return true;
    }

    public static function delete($filepath) {
        if (file_exists($filepath)) {
            return unlink($filepath);
        }

        return false;
    }

    public static function getInfo($filepath) {
        if (!file_exists($filepath)) {
            throw new Exception("File non trovato: $filepath");
        }

        return [
            'name' => basename($filepath),
            'size' => filesize($filepath),
            'type' => mime_content_type($filepath),
            'modified' => filemtime($filepath),
            'permissions' => fileperms($filepath),
            'is_readable' => is_readable($filepath),
            'is_writable' => is_writable($filepath)
        ];
    }
}

// CSV Handler
class CSVHandler {
    public static function read($filepath, $delimiter = ',', $has_header = true) {
        if (!file_exists($filepath)) {
            throw new Exception("File CSV non trovato");
        }

        $data = [];
        $headers = [];

        if (($handle = fopen($filepath, 'r')) !== false) {
            $row_number = 0;

            while (($row = fgetcsv($handle, 1000, $delimiter)) !== false) {
                if ($row_number === 0 && $has_header) {
                    $headers = $row;
                } else {
                    if ($has_header && !empty($headers)) {
                        $data[] = array_combine($headers, $row);
                    } else {
                        $data[] = $row;
                    }
                }
                $row_number++;
            }

            fclose($handle);
        }

        return $data;
    }

    public static function write($filepath, $data, $headers = null, $delimiter = ',') {
        if (($handle = fopen($filepath, 'w')) === false) {
            throw new Exception("Impossibile aprire il file per scrittura");
        }

        // Scrivi intestazioni
        if ($headers) {
            fputcsv($handle, $headers, $delimiter);
        }

        // Scrivi dati
        foreach ($data as $row) {
            fputcsv($handle, $row, $delimiter);
        }

        fclose($handle);
        return true;
    }
}

// Logger
class Logger {
    private $log_file;

    public function __construct($log_file = 'app.log') {
        $this->log_file = $log_file;
    }

    public function log($level, $message, $context = []) {
        $timestamp = date('Y-m-d H:i:s');
        $context_str = !empty($context) ? json_encode($context) : '';

        $log_entry = "[$timestamp] $level: $message $context_str" . PHP_EOL;

        FileManager::write($this->log_file, $log_entry, true);
    }

    public function info($message, $context = []) {
        $this->log('INFO', $message, $context);
    }

    public function warning($message, $context = []) {
        $this->log('WARNING', $message, $context);
    }

    public function error($message, $context = []) {
        $this->log('ERROR', $message, $context);
    }
}

// Esempi di utilizzo
try {
    // Lettura file
    $content = FileManager::read('config.txt');
    echo "Contenuto file: $content";

    // Scrittura file
    FileManager::write('output.txt', "Hello, World!\n");

    // Info file
    $info = FileManager::getInfo('output.txt');
    print_r($info);

    // CSV
    $csv_data = [
        ['Nome', 'Età', 'Email'],
        ['Mario', 30, 'mario@email.com'],
        ['Anna', 25, 'anna@email.com']
    ];

    CSVHandler::write('users.csv', array_slice($csv_data, 1), $csv_data[0]);
    $loaded_data = CSVHandler::read('users.csv');
    print_r($loaded_data);

    // Logging
    $logger = new Logger();
    $logger->info('Applicazione avviata');
    $logger->error('Errore di connessione', ['host' => 'localhost']);

} catch (Exception $e) {
    echo "Errore: " . $e->getMessage();
}
?>

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

<?php
class DirectoryManager {
    public static function create($path, $permissions = 0755, $recursive = true) {
        if (!is_dir($path)) {
            return mkdir($path, $permissions, $recursive);
        }

        return true;
    }

    public static function delete($path, $recursive = false) {
        if (!is_dir($path)) {
            return false;
        }

        if ($recursive) {
            $files = array_diff(scandir($path), ['.', '..']);

            foreach ($files as $file) {
                $file_path = $path . DIRECTORY_SEPARATOR . $file;

                if (is_dir($file_path)) {
                    self::delete($file_path, true);
                } else {
                    unlink($file_path);
                }
            }
        }

        return rmdir($path);
    }

    public static function listFiles($path, $filter = '*') {
        if (!is_dir($path)) {
            throw new Exception("Directory non trovata: $path");
        }

        $pattern = $path . DIRECTORY_SEPARATOR . $filter;
        return glob($pattern);
    }

    public static function size($path) {
        $size = 0;

        if (is_file($path)) {
            return filesize($path);
        }

        if (is_dir($path)) {
            $files = array_diff(scandir($path), ['.', '..']);

            foreach ($files as $file) {
                $file_path = $path . DIRECTORY_SEPARATOR . $file;
                $size += self::size($file_path);
            }
        }

        return $size;
    }

    public static function copy($source, $destination) {
        if (is_file($source)) {
            return copy($source, $destination);
        }

        if (is_dir($source)) {
            self::create($destination);

            $files = array_diff(scandir($source), ['.', '..']);

            foreach ($files as $file) {
                $source_path = $source . DIRECTORY_SEPARATOR . $file;
                $dest_path = $destination . DIRECTORY_SEPARATOR . $file;

                self::copy($source_path, $dest_path);
            }

            return true;
        }

        return false;
    }
}

// Path Utilities
class PathUtils {
    public static function join(...$parts) {
        return implode(DIRECTORY_SEPARATOR, array_filter($parts, 'strlen'));
    }

    public static function normalize($path) {
        return realpath($path);
    }

    public static function relativePath($from, $to) {
        $from = explode(DIRECTORY_SEPARATOR, $from);
        $to = explode(DIRECTORY_SEPARATOR, $to);

        while (count($from) && count($to) && $from[0] === $to[0]) {
            array_shift($from);
            array_shift($to);
        }

        return str_repeat('..'.DIRECTORY_SEPARATOR, count($from)) . implode(DIRECTORY_SEPARATOR, $to);
    }

    public static function extension($path) {
        return pathinfo($path, PATHINFO_EXTENSION);
    }

    public static function filename($path, $include_extension = true) {
        return $include_extension
            ? pathinfo($path, PATHINFO_BASENAME)
            : pathinfo($path, PATHINFO_FILENAME);
    }

    public static function directory($path) {
        return pathinfo($path, PATHINFO_DIRNAME);
    }
}

// Esempi
try {
    // Creare directory
    DirectoryManager::create('test/subdir');

    // Listar file
    $files = DirectoryManager::listFiles('.', '*.php');
    echo "File PHP trovati: " . count($files) . "\n";

    // Dimensione directory
    $size = DirectoryManager::size('.');
    echo "Dimensione directory: " . number_format($size) . " bytes\n";

    // Path operations
    $path = PathUtils::join('var', 'www', 'html', 'index.php');
    echo "Path: $path\n";

    echo "Extension: " . PathUtils::extension($path) . "\n";
    echo "Filename: " . PathUtils::filename($path) . "\n";
    echo "Directory: " . PathUtils::directory($path) . "\n";

} catch (Exception $e) {
    echo "Errore: " . $e->getMessage() . "\n";
}
?>

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

# Installare Composer globalmente
curl -sS https://getcomposer.org/installer | php
sudo mv composer.phar /usr/local/bin/composer

# Creare nuovo progetto
mkdir my-php-project
cd my-php-project

# Inizializzare Composer
composer init

# Installare pacchetti
composer require monolog/monolog
composer require guzzlehttp/guzzle
composer require --dev phpunit/phpunit

# Aggiornare dipendenze
composer update

# Installare dipendenze da composer.json esistente
composer install

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

{
    "name": "mycompany/my-project",
    "description": "Un progetto PHP di esempio",
    "type": "project",
    "require": {
        "php": ">=8.0",
        "monolog/monolog": "^3.0",
        "guzzlehttp/guzzle": "^7.0",
        "doctrine/dbal": "^3.0"
    },
    "require-dev": {
        "phpunit/phpunit": "^10.0",
        "squizlabs/php_codesniffer": "^3.0"
    },
    "autoload": {
        "psr-4": {
            "MyProject\\": "src/"
        }
    },
    "autoload-dev": {
        "psr-4": {
            "MyProject\\Tests\\": "tests/"
        }
    },
    "scripts": {
        "test": "phpunit",
        "lint": "phpcs src/ --standard=PSR12",
        "fix": "phpcbf src/ --standard=PSR12"
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79