Le variabili in PHP sono identificate da un $ seguito dal nome, mentre le costanti sono valori immutabili definiti con define() o usando la parola chiave const. Le costanti non cambiano durante l'esecuzione dello script.
define("PI", 3.14); // Costante
$radius = 5; // VariabilePHP supporta vari tipi di dato: scalari (booleani, interi, numeri in virgola mobile, stringhe), composti (array, oggetti), e speciali come null.
$boolean = true; // Boolean
$integer = 42; // Integer
$float = 3.1416; // Float
$string = "Hello, World!"; // String
$array = [1, 2, 3]; // ArrayI valori booleani (true e false) sono usati per rappresentare uno stato binario e vengono spesso utilizzati nelle espressioni condizionali.
$isTrue = true;
if ($isTrue) {
echo "It's true!";
}PHP supporta i numeri interi, che sono numeri senza parte decimale. Gli interi possono essere rappresentati in base decimale, ottale o esadecimale.
$decimal = 42; // Base decimale
$octal = 052; // Base ottale
$hex = 0x2A; // Base esadecimaleI numeri in virgola mobile (o numeri decimali) rappresentano numeri con una parte frazionaria e sono utili per calcoli matematici più complessi.
$float = 3.14;
echo $float * 2; // Output: 6.28Le stringhe sono sequenze di caratteri. PHP fornisce molte funzioni per manipolare stringhe, come strlen() e str_replace().
$string = "PHP";
echo strlen($string); // Output: 3
echo str_replace("P", "J", $string); // Output: JHJIl tipo null rappresenta una variabile senza valore. Una variabile è null se è stata dichiarata ma non ha ancora ricevuto un valore.
$variable = null;
if (is_null($variable)) {
echo "This is null";
}Gli array in PHP sono strutture dati che possono contenere valori multipli. Possono essere indicizzati numericamente o associativamente.
$array = ["apple", "banana", "cherry"];
echo $array[1]; // Output: bananaUn'espressione in PHP è tutto ciò che restituisce un valore, come operazioni matematiche o assegnazioni.
$result = 5 + 3; // L'espressione restituisce 8PHP offre vari tipi di operatori, inclusi aritmetici (+, -), di confronto (==, !=), logici (&&, ||), e di assegnazione (=).
$a = 5;
$b = 10;
echo $a + $b; // Operatore aritmetico
echo $a == $b; // Operatore di confrontoLe espressioni condizionali controllano il flusso del programma in base a condizioni logiche. if, elseif, e else eseguono blocchi di codice diversi a seconda dei risultati delle condizioni.
$score = 85;
if ($score >= 90) {
echo "A";
} elseif ($score >= 80) {
echo "B";
} else {
echo "C";
}I cicli permettono di ripetere l'esecuzione di un blocco di codice. foreach itera su array, mentre for, do, e while sono cicli generici.
$fruits = ["apple", "banana", "cherry"];
foreach ($fruits as $fruit) {
echo $fruit . " ";
}Il costrutto switch permette di eseguire diversi blocchi di codice in base al valore di un'espressione, facilitando il controllo condizionale multiplo.
$day = 3;
switch ($day) {
case 1:
echo "Monday";
break;
case 2:
echo "Tuesday";
break;
case 3:
echo "Wednesday";
break;
}Il costrutto match introdotto in PHP 8 è simile a switch, ma più potente e pulito, poiché può restituire direttamente un valore e gestisce il confronto con identità stretta.
$day = 3;
echo match ($day) {
1 => "Monday",
2 => "Tuesday",
3 => "Wednesday",
};return restituisce un valore da una funzione, declare modifica alcune direttive di esecuzione del codice, e goto permette di saltare a un'istruzione specificata (è usato raramente, tu non usarlo MAI).
function sum($a, $b) {
return $a + $b;
}PHP consente di includere file esterni usando include o require, utili per organizzare il codice in più file.
include 'header.php';Le funzioni sono blocchi di codice riutilizzabili che accettano parametri e possono restituire valori. Sono dichiarate con la parola chiave function.
function greet($name) {
echo "Hello, " . $name;
}
greet("John");I parametri sono variabili dichiarate in una funzione, mentre gli argomenti sono i valori passati alla funzione durante la chiamata.
function add($a, $b) {
return $a + $b;
}
echo add(3, 4); // Output: 7La visibilità delle variabili dipende dal contesto in cui sono dichiarate: globale, locale o di una classe (proprietà).
$globalVar = "Global";
function test() {
global $globalVar;
echo $globalVar;
}Le funzioni possono essere definite dall'utente o predefinite. PHP offre numerose funzioni integrate per manipolare stringhe, array, file e altro.
// Funzione definita dall'utente
function square($n) {
return $n * $n;
}
echo square(4); // Output: 16PHP offre diverse funzioni per la manipolazione degli array, come array_merge(), array_push(), e array_filter().
$array = [1, 2, 3, 4, 5];
array_push($array, 6);
print_r($array); // Output: Array ( [0] => 1 [1] => 2 [2] => 3 [3] => 4 [4] => 5 [5] => 6 )PHP permette di leggere, scrivere, modificare e eliminare file usando funzioni come fopen(), fwrite(), e fclose().
$file = fopen("test.txt", "r");
$content = fread($file, filesize("test.txt"));
fclose($file);PHP gestisce date e ore tramite la classe DateTime e le funzioni date() e strtotime(). È possibile configurare il fuso orario usando date_default_timezone_set().
date_default_timezone_set('Europe/Rome');
echo date('Y-m-d H:i:s');PHP gestisce errori con varie modalità: errori fatali, avvisi e notifiche. Si possono utilizzare blocchi try-catch per gestire le eccezioni.
try {
$result = 5 / 0;
} catch (DivisionByZeroError $e) {
echo "Error: Division by zero.";
}php.ini è il file di configurazione principale di PHP, che definisce comportamenti come la dimensione massima dei file caricati e il limite di memoria.
Modifica php.ini per impostare, ad esempio, il limite di memoria:
memory_limit = 128MPer eseguire PHP con Apache, bisogna configurare il modulo mod_php. Le impostazioni di PHP possono essere modificate attraverso il file .htaccess.
Aggiungi nel file .htaccess:
php_value upload_max_filesize 10M
Docker permette di creare ambienti di sviluppo consistenti e isolati. Si può utilizzare un’immagine Docker con PHP e altri servizi necessari per l’applicazione.
docker run -d -p 8080:80 -v $(pwd):/var/www/html php:7.4-apacheComposer è un gestore di dipendenze per PHP che permette di includere librerie di terze parti nel progetto tramite il file composer.json.
composer require guzzlehttp/guzzleLa OOP in PHP permette di organizzare il codice in classi e oggetti, promuovendo la riusabilità e la manutenibilità del codice.
class Person {
public $name;
public function greet() {
echo "Hello, " . $this->name;
}
}Una classe è un modello per creare oggetti. Gli oggetti sono istanze delle classi e possono contenere proprietà e metodi.
class Car {
public $color;
}
$myCar = new Car();
$myCar->color = "Red";Introdotta in PHP 8, la promozione dei parametri permette di dichiarare e inizializzare le proprietà della classe direttamente nel costruttore, riducendo il codice boilerplate.
class Point {
public function __construct(public int $x, public int $y) {}
}L'operatore nullsafe (?->) in PHP 8 consente di evitare errori quando si accede a proprietà o metodi di un oggetto che può essere nullo.
$person = null;
echo $person?->name;Gli spazi dei nomi (namespace) permettono di organizzare il codice evitando conflitti tra classi, funzioni o costanti con lo stesso nome.
namespace MyApp\Utils;
class Helper {
public static function greet() {
echo "Hello!";
}
}Il caricamento automatico (autoloading) permette di caricare automaticamente le classi quando sono necessarie, senza richiedere manualmente i file.
spl_autoload_register(function ($class_name) {
include $class_name . '.php';
});Le costanti di classe sono valori immutabili definiti all'interno di una classe con la parola chiave const, accessibili tramite self:: o il nome della classe.
class Math {
const PI = 3.14;
}
echo Math::PI;Le proprietà e i metodi statici appartengono alla classe e non alle istanze. Possono essere accessibili senza creare un oggetto.
class Counter {
public static $count = 0;
public static function increment() {
self::$count++;
}
}
Counter::increment();
echo Counter::$count;I quattro principi dell’OOP sono: astrazione, incapsulamento, ereditarietà e polimorfismo, che permettono una struttura modulare e flessibile.
// Esempio di Incapsulamento
class BankAccount {
private $balance = 0;
public function deposit($amount) {
$this->balance += $amount;
}
public function getBalance() {
return $this->balance;
}
}Le classi astratte non possono essere istanziate e possono contenere metodi astratti, che devono essere implementati nelle sottoclassi.
abstract class Animal {
abstract public function sound();
}
class Dog extends Animal {
public function sound() {
echo "Woof!";
}
}Le interfacce definiscono un contratto per le classi che le implementano. Il polimorfismo permette di trattare oggetti di diverse classi in modo uniforme.
interface Vehicle {
public function drive();
}
class Car implements Vehicle {
public function drive() {
echo "Driving a car.";
}
}L'ereditarietà permette a una classe di ereditare proprietà e metodi da un'altra classe, creando una gerarchia di classi.
class Animal {
public $name;
public function speak() {
echo "Animal sound";
}
}
class Dog extends Animal {
public function speak() {
echo "Woof!";
}
}I traits permettono di riutilizzare il codice in più classi, simulando l'ereditarietà multipla, che non è supportata direttamente in PHP.
trait Logger {
public function log($message) {
echo $message;
}
}
class Application {
use Logger;
}
$app = new Application();
$app->log("Starting application");Le classi anonime sono classi senza nome che possono essere create dinamicamente e utilizzate per scopi specifici o temporanei.
$greeting = new class {
public function sayHello() {
echo "Hello, World!";
}
};
$greeting->sayHello();PHP include metodi speciali detti "magici", come __construct(), __get(), e __set(), che svolgono operazioni speciali o automatizzano comportamenti degli oggetti.
class Person {
private $name;
public function __get($property) {
return "Getting " . $property;
}
}Ecco una panoramica dei vari argomenti con una breve spiegazione e un piccolo esempio introduttivo per ciascuno.
La programmazione per il web riguarda lo sviluppo di applicazioni o siti web utilizzando linguaggi di scripting lato server come PHP. PHP consente di generare contenuti dinamici, interagire con i database e gestire le richieste HTTP (GET e POST).
Esempio:
<?php
echo "Benvenuti nel sito web dinamico!";
?>I metodi GET e POST vengono utilizzati per inviare dati dal client al server. GET trasmette i dati nell'URL, mentre POST li invia nel corpo della richiesta, utile per gestire dati sensibili o lunghi.
Esempio:
// GET: url?nome=Mario
echo $_GET['nome']; // Output: Mario
// POST (da un form HTML)
echo $_POST['nome'];Con PHP è possibile caricare file tramite moduli HTML. La gestione del caricamento avviene con la variabile superglobale $_FILES.
Esempio:
<form action="upload.php" method="POST" enctype="multipart/form-data">
<input type="file" name="fileCaricato">
<button type="submit">Carica</button>
</form>upload.php:
if (move_uploaded_file($_FILES['fileCaricato']['tmp_name'], 'uploads/' . $_FILES['fileCaricato']['name'])) {
echo "File caricato con successo!";
}I cookie sono piccoli file salvati sul client che memorizzano dati persistenti, mentre le sessioni memorizzano dati temporanei sul server per ogni utente.
Esempio Cookie:
setcookie("nome", "Mario", time() + 3600); // Scade dopo 1 ora
echo $_COOKIE['nome']; // Output: MarioEsempio Sessione:
session_start();
$_SESSION['utente'] = 'Mario';
echo $_SESSION['utente']; // Output: MarioLe API REST forniscono un'interfaccia per comunicare con altre applicazioni. I dati vengono spesso trasferiti nel formato JSON.
Esempio API REST che restituisce JSON:
header('Content-Type: application/json');
$risposta = ['stato' => 'successo', 'messaggio' => 'Dati ricevuti'];
echo json_encode($risposta);L'accesso ai dati implica leggere e scrivere dati provenienti da file, database o altre sorgenti di dati. In PHP, si possono usare tecniche come l'input/output dei file e le query ai database per gestire i dati.
Esempio Lettura file:
$contenuto = file_get_contents('dati.txt');
echo $contenuto;PHP permette di manipolare file: aprirli, modificarli, leggerli o cancellarli.
Esempio Scrittura su file:
$file = fopen("dati.txt", "w");
fwrite($file, "Ciao, mondo!");
fclose($file);PDO (PHP Data Objects) è un'interfaccia che permette di interagire con diversi database in modo sicuro e flessibile.
Esempio Connessione con PDO:
$pdo = new PDO('mysql:host=localhost;dbname=test', 'username', 'password');
$statement = $pdo->query("SELECT * FROM utenti");
$utenti = $statement->fetchAll();La gestione dei progetti in PHP include l'organizzazione del codice, la configurazione di ambienti di sviluppo, e l'uso di strumenti per la gestione delle dipendenze e del codice sorgente (es. Composer, Git).
L'autoloading carica automaticamente le classi quando vengono richieste, evitando l'inclusione manuale con require. Composer è uno strumento per la gestione delle dipendenze in PHP.
Esempio di autoloading con Composer:
composer init
composer require monolog/monologrequire 'vendor/autoload.php';PHPUnit è un framework per i test unitari in PHP che permette di verificare la correttezza del codice.
Esempio test:
use PHPUnit\Framework\TestCase;
class TestUtente extends TestCase {
public function testNome() {
$utente = new Utente("Mario");
$this->assertEquals("Mario", $utente->getNome());
}
}Il pattern MVC (Model-View-Controller) separa la logica dell'applicazione (Model), la presentazione (View), e la gestione delle richieste (Controller).
Esempio semplice di MVC:
// Model
class Utente {
public function getNome() {
return "Mario";
}
}
// Controller
class UtenteController {
public function mostraNome() {
$utente = new Utente();
include "view.php";
}
}
// View (view.php)
echo $utente->getNome();PHP offre due modi principali per connettersi a un database MySQL: MySQLi e PDO.
Esempio connessione con MySQLi:
$conn = new mysqli('localhost', 'username', 'password', 'database');