PHP 8.3: le novità della nuova versione

Introduzione

Le versioni Minor di PHP, come PHP 8.3, introducono miglioramenti e funzionalità.

1. Aggiunta dei Typed Class Constants

PHP 8.3 introduce i Typed Class Constants, permettendo ai programmatori di dichiarare costanti di classe tipizzate.


class Example {
    public const string NAME = 'Esempio';
}



interface I {
    const string PHP = 'PHP 8.1';
}

class Bar83 implements I {
    const string PHP = 'PHP 8.3';
}
echo 'Bar83::PHP: ' . Bar83::PHP; //print 'PHP 8.3'

class FooPHPArr implements I {
    const string PHP = []; // Fatal error: Cannot use array as value for class constant FooPHPArr::PHP of type string
}

2. Attributo #[\Override]

Con l’aggiunta dell’attributo #[\Override] a un metodo, PHP si assicura che esista un metodo con lo stesso nome in una classe genitore o in un’interfaccia implementata. Questa funzionalità rende sia piu leggibile il codice che semplificato il refactoring in quanto verrà rilevata la rimozione o il rename di un metodo sovrascritto.


//classe padre
class TestCase {

    protected function setUp(): void {
    }

    protected function tearDown(): void {
    }
}

/*

PHP < 8.3

final class MyTest extends TestCase {
    protected $logFile;

    protected function setUp(): void {
        $this->logFile = fopen('/tmp/logfile', 'w');
    }

    protected function taerDown(): void {
        fclose($this->logFile);
        unlink('/tmp/logfile');
    }
}

// The log file will never be removed, because the
// method name was mistyped (taerDown vs tearDown).

*/

//PHP 8.3

final class MyTest extends TestCase {
    protected $logFile;

    #[\Override]
    protected function setUp(): void {
        $this->logFile = fopen('/tmp/logfile', 'w');
    }

    #[\Override]
    //protected function taerDown(): void {
    protected function tearDown(): void {
        fclose($this->logFile);
        unlink('/tmp/logfile');
    }
}
// PHP Fatal error:  MyTest::taerDown() has #[\Override] attribute, but no matching parent method exists

3. funzione json_validate()

la funzione json_validate() verifica se una stringa è un JSON valido.



var_dump(json_validate('{ "test": { "foo": "bar" } }')); // true


4. nuovi metodi di Randomizer

La Random Extension introdotta nelle versioni precedentei, con PHP 8.3 viene arricchita di nuovi metodi.

Il metodo getBytesFromString restituisce una sringa causale di caratteri estratti dalla stringa di caratteri passata come argomento.


$randomizer = new \Random\Randomizer();
printf(
    "%s.example.com",
    $randomizer->getBytesFromString('abcdefghijklmnopqrstuvwxyz0123456789', 16)
);
output something similar to:
3zsw04eiubcf82jd.example.com

Il metodo getFloat(float $min, float $max, Random\IntervalBoundary $boundary = Random\IntervalBoundary::ClosedOpen): float
restituisce un numero float casuale, quanto piu possibile uniformemente distribuito dall intervallo ($min, $max).


Generate a random latitude and longitude:
$randomizer = new \Random\Randomizer();
// Note that the latitude granularity is double the
// longitude's granularity.
//
// For the latitude the value may be both -90 and 90.
// For the longitude the value may be 180, but not -180, because
// -180 and 180 refer to the same longitude. ???
var_dump(sprintf(
    "Lat: %+.6f Lng: %+.6f",
    $randomizer->getFloat(-90, 90, \Random\IntervalBoundary::ClosedClosed),
    $randomizer->getFloat(-180, 180, \Random\IntervalBoundary::OpenClosed),
)); // string(32) "Lat: -51.742529 Lng: +135.396328"



Il metodo nextFloat(): float
restituisce un numero float casuale, quanto piu possibile uniformemente distribuito dall’intervallo semiaperto [0, 1).


$r = new \Random\Randomizer();
print $r->nextFloat();

Riferimenti Utili

Processo di Evoluzione e Sviluppo di PHP

Il processo di evoluzione e sviluppo di un linguaggio di programmazione, come PHP, è complesso e coinvolge molte fasi. Di seguito, esploreremo ogni fase con esempi concreti.

1. Definizione degli obiettivi e roadmap

PHP nacque negli anni ’90, inizialmente come linguaggio per generare pagine web dinamiche. Con l’avanzare delle necessità di sviluppo, PHP si è evoluto per gestire applicazioni più complesse, migliorando le sue prestazioni e la sicurezza. Ogni nuova versione risponde a obiettivi specifici, come le performance di PHP 7, che ha notevolmente aumentato la velocità rispetto a PHP 5.

2. Community di sviluppatori e governance

PHP è un progetto open-source, e la community è fondamentale per il suo sviluppo. Le decisioni vengono prese attraverso mailing list pubbliche (PHP Internals) e tramite il contributo di membri come il PHP-FIG (PHP Framework Interoperability Group). Il PHP-FIG ha introdotto standard come le PHP Standards Recommendations (PSR) per migliorare l’interoperabilità.

3. Proposte di cambiamento e revisione delle RFC

Nuove funzionalità passano attraverso un processo chiamato Request for Comments (RFC). Ad esempio, per introdurre il supporto ai tipi dichiarati (introdotti in PHP 7), venne creata una RFC che spiegava le motivazioni e gli esempi d’uso. Dopo il voto favorevole della community, questa modifica venne implementata nella versione finale.

4. Fasi di implementazione e testing

Una volta approvate, le funzionalità vengono implementate e testate. Ad esempio, per PHP 8 sono stati usati test automatici per introdurre Just-in-Time Compilation (JIT), una funzione che migliora le prestazioni per calcoli complessi.

5. Versioni stabili e supporto

PHP segue un ciclo di rilascio regolare, con versioni principali ogni due anni. Ogni versione è supportata per circa tre anni. Ecco una tabella con le principali versioni di PHP e le rispettive date di rilascio:

Versione Data di Rilascio Caratteristiche Principali
PHP 5.0 13 luglio 2004 Supporto OOP (Object-Oriented Programming)
PHP 5.3 30 giugno 2009 Namespaces, anonime closures
PHP 5.6 28 agosto 2014 Variadic functions, operatori null coalescing
PHP 7.0 3 dicembre 2015 Miglioramento delle prestazioni, tipi scalari
PHP 7.4 28 novembre 2019 Typed Properties, Arrow Functions
PHP 8.0 26 novembre 2020 JIT, Named Arguments, Union Types
PHP 8.1 25 novembre 2021 Enumerazioni, Fibers
PHP 8.2 8 dicembre 2022 Readonly properties, Deprecation di dynamic properties

6. Feedback continuo e miglioramento

Il feedback della community è essenziale. Gli sviluppatori segnalano errori e propongono miglioramenti tramite piattaforme come PHP Bug Tracking e GitHub. Questo feedback contribuisce a un’evoluzione costante del linguaggio.

Conclusioni

Il processo di sviluppo di PHP si basa sulla collaborazione tra una community mondiale di sviluppatori e un solido processo di governance. Per rimanere aggiornati, è possibile fare riferimento alle seguenti risorse ufficiali:

PHP 8.0: le novità della nuova versione

Introduzione

PHP è un linguaggio in costante evoluzione, con aggiornamenti rilasciati periodicamente per migliorare le prestazioni, aggiungere nuove funzionalità e aumentare la sicurezza. Ogni versione Major, come PHP 8.0, introduce cambiamenti significativi rispetto alle versioni precedenti. PHP 8.0, rilasciato nel novembre 2020, rappresenta una delle release più importanti degli ultimi anni, con numerosi aggiornamenti al linguaggio e nuove funzionalità.

1. JIT Compiler (Just-In-Time)

Una delle principali novità di PHP 8.0 è l’integrazione di un JIT Compiler, che migliora le prestazioni del codice PHP compilando parti di esso in tempo reale. Il JIT può ridurre il tempo di esecuzione di script complessi, soprattutto in ambiti di elaborazione intensiva.
Documentazione ufficiale: JIT Compiler.
JIT è implementato nell’estensione Opcache, ed è necessario che l’estensione php Opcache sia attivata.


opcache.enable=1
opcache.enable_cli=1
opcache.jit_buffer_size = 100M
opcache.jit = tracing

2. Operatore Nullsafe

L’operatore nullsafe consente di evitare errori di accesso a proprietà o metodi su oggetti nulli. È una soluzione compatta per la gestione del valore null.
L’operatore nullsafe consente di compattare il codice nei casi in cui bisogna verificare se un oggetto è null prima di accedere alle sue proprietà.


$userName = $user?->profile?->getName();


$country =  null;
if ($session !== null) {
    $user = $session->user;
     if ($user !== null) {
        $address = $user->getAddress();
         if ($address !== null) {
            $country = $address->country;
        }
    }
}
// do something with $country

// con l'operatore nullsafe il codice di prima si puo riscrivere in forma più compatta così:
$country = $session?->user?->getAddress()?->country;
// do something with $country




3. Named Arguments

PHP 8.0 introduce i named arguments, che permettono di specificare i valori degli argomenti associandoli direttamente ai loro nomi.
I Named Arguments consentono di passare argomenti a una funzione in base al nome del parametro, anziché alla posizione del parametro, ciò rende rende gli argomenti indipendenti dall’ordine in cui sono definiti nella firma della funzione. Inoltre, nel caso di di parametri opzionali con valori predefiniti, consente passare solo gli argomenti desiderati, saltando arbitrariamente i valori predefiniti.
Questa funzionalità migliora la leggibilità e la flessibilità del codice.


function createUser(string $name, int $age, bool $isActive) {
    // Creazione utente
}
createUser(age: 30, name: "Mario", isActive: true);

Questo esempio di codice (che utilizz htmlspecialchars): mostra che non è piu necessario specificare tutti i valori predefiniti fino a quello che si vuole modificare. Gli Named Arguments consentono di sovrascrivere direttamente solo i valori predefiniti che si desidera modificare rispetto al valore di default.


htmlspecialchars — Convert special characters to HTML entities
htmlspecialchars(
    string $string,
    int $flags = ENT_QUOTES | ENT_SUBSTITUTE | ENT_HTML401,
    ?string $encoding = null,
    bool $double_encode = true
): string

// con Named Arguments
htmlspecialchars($string, double_encode: false);
// senza Named Arguments 
htmlspecialchars($string, ENT_QUOTES | ENT_SUBSTITUTE | ENT_HTML401, null, false);


4. Union Types

Con union types è possibile specificare più tipi di dati sia per un parametro di input che per il valore di ritorno di una funzione.


function processInput(int|string $input): int|string {
    // Logica di elaborazione
}

5. Funzione str_contains

PHP 8.0 introduce la funzione str_contains per verificare se una stringa contiene un’altra stringa. Questa funzione è molto utile per la gestione di stringhe e sostituisce soluzioni meno leggibili.


$result = str_contains("Hello, World!", "World"); // true

6. Funzione match

La nuova funzione match introduce un’espressione di controllo simile a switch, ma con una sintassi più pulita e flessibile, la funzione crestituisce l’esito del match che puo richiamare a sua volta una funzione.


$action = match ($status) {
    1 => 'Active',
    2 => 'Inactive',
    default => 'Unknown',
};

Conclusione

PHP 8.0 è una versione ricca di innovazioni, che migliora le prestazioni del linguaggio e semplifica la scrittura del codice.

Riferimenti Utili