PHP

TIOBE avril 2024 : le plus mauvais classement de PHP

Soumis par fredericmazue le

Au lancement de l'index TIOBE en 2001, la popularité de PHP ne cessait de croître. Il avait même atteint la troisième place du classement. Mais la roue tourne et PHP est en chute libre désoermais. Ce mois d'avril 2024, il connaît ainsi son plus mauvais classement, à la 17ème place, devant Kotlin et Rust. Ces deux derniers langages progressant lentement mais sûrement, la chûte de PHP n'est sans doute pas terminée.

L'index TIOBE est souvent plein de surprise. Ainsi nous constatons ce mois que Fortran a réalisé une progression de près de 1% sur l'année écoulée, pour se hisser à la 10ème place.

PHP 8.3 est sorti

Soumis par fredericmazue le

Conformément à sa feuille de route, le projet PHP a anoncé la disponibilité de PHP 8.3 le 23 novembre dernier. Il s'agit d'une version majeure qui apporte, en plus des classiques améliorations de performances et corrections de bugs, un lot conséquent de nouveautés. Nous vous en présentons ici 2, choisie tout à fait subjectivement : les constantes de classes typées et la nouvelle fonction json_validate.

Les constantes de classes typées

Avant PHP 8.3, nous avions ceci :

interface I {
// We may naively assume that the PHP constant is always a string.
const PHP = 'PHP 8.2';
}

class Foo implements I {
// But implementing classes may define it as an array.
const PHP = [];
}

Dans cet échantillon de code, une implémentation d'une interface redéfinit le type d'une constante de classe. Avec PHP 8.3, ceci peut être rendu impossible en déclarant explicitement le type des constantes de classe, ce qui assainit notablement le code

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

class Foo implements I {
const string PHP = [];
}

// Fatal error: Cannot use array as value for class constant
// Foo::PHP of type string

json_validate

Cette fonction permet de vérifier qu'une chaîne de caractère est du code JSON valide syntaxiquement. Avant PHP 8.3, nous pouvions procéder ainsi :

function json_validate(string $string): bool {
json_decode($string);

return json_last_error() === JSON_ERROR_NONE;
}

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

 

Ce qui, objectivement, est inélégant. Avec PHP 8.3, la même validation JSON est directe :

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

Retrouvez la liste complète des nouveautés de PHP 8.3 dans sa note de version.

Commentaire actu

PHP 8.2 est sorti

Soumis par fredericmazue le

Le projet PHP a annoncé la disponibilité d'une nouvelle version du célèbre langage de développement Web : PHP 8.2. Il s'agit d'une version riche en nouveautés.

On remarque notamment l'arrivée des classes en lecture seule. Après l'arrivée, avec PHP 8.1, du mot-clé read-only pour déclarer les propriétés d'une classe en lecture seule, arrive, avec PHP 8.2, la possibilité d'utiliser ce même mot-clé sur toute une classe. Ce qui allégera le code et le rendra plus clair dans de nombreux cas. Il est important de remarquer que déclarer une classe en lecture seule empêche la création de propriétés dynamiques dans la dite classe :

readonly class Foo
{
    public int $bar;

    public function __construct() {
        $this->bar = 1;
    }
}

$foo = new Foo();
$foo->bar = 2;
// Fatal Error: Uncaught Error: Cannot modify readonly property Foo::$bar

$foo->baz = 1;
// Fatal Error: Uncaught Error: Cannot create dynamic property Foo::$baz

On remarque encore l'arrivée de la fonction mysqli_execute_query, une nouvelle fonction qui devrait simplifier la vie des développeurs au quotidien. Cette nouvelle fonciton est une simple combinaison de

  1. mysqli_prepare()
  2. mysqli_execute()
  3. mysqli_stmt_get_result()

On remarque enfin l'arrivée de null et false en tant que types autonomes, utilisables partout où les déclarations de type sont actuellement autorisées. Par exemple :

class Nil {
    public null $nil = null;

    public function foo(null $v): null { /* ... */ *}
} 

Toutes les nouveautés de PHP 8.2 sont récapitulées dans sa note de version. 

PHP 8.2 RC1

Soumis par fredericmazue le

Le projet vient d'annoncer la disponibilité de PHP 8.2 en Release Candidate. Pour l'occasion l'équipe rappelle que PHP 8.2 RC reste une version de test qui ne doit pas être utilisée en production.

Cette mouture contient de nombreuses nouveautés. En voici quelques-unes :

Classes readonly

Les propriétés en lecture seule ont été introduites dans PHP 8.1. Les classes readonly s'appuient dessus et sont essentiellement un sucre syntaxique qui permet de rendre toutes les propriétés d'une classe en lecture seule en une seule fois. Au lieu de 

class Post
{
    public function __construct(
        public readonly string $title, 
       public readonly Author $author,
        public readonly string $body,
        public readonly DateTime $publishedAt,
    ) {}
}

On écrira simplement :

readonly class Post
{
    public function __construct(
        public string $title, 
        public Author $author,
        public string $body,
        public DateTime $publishedAt,
    ) {}
}

Des classes abstraites et des classes finales peuvent également être déclarées readonly. L'ordre des mots clés ne fait aucune différence.

abstract readonly class Foo {}
final readonly class Bar {}

True devient un type autonome

PHP 8.2 permet l'utilisation true en tant que type, en tant que type autonome et dans le cadre d'un type Union. 

Donc true peut être utilisé comme type partout où PHP accepte un type :

class Foo {
    private true $processed;
    public function process(string|int|true $value): true {
    }
}

Le type true n'est pas coercitif. Lorsqu'un paramètre, une propriété ou un type de retour est déclaré comme true, PHP ne fait pas de coercition d'un autre type vers true.

Par exemple, l'appel de fonction suivant ne convertit pas la valeur entière 1 à true, et génère une erreur de type :  TypeError:

function foo(true $value) {}
foo(1);
TypeError: foo(): Argument #1 ($value) must be of type true, int given, called in ... on line ... and defined in ...:...

Nouvelles fonctionnalité MySQLi

Dans PHP 8.2, l'extension MySQLi fournit une approche plus simple pour préparer, lier, exécuter et récupérer les résultats d'une requête SQL avec une nouvelle fonction mysqli_execute_query et une nouvelle méthode mysqli::execute_query.

Sans la fonction mysqli_execute_query, une requête paramétrée est exécutée avec beaucoup de code passe-partout comme ceci :

$query = 'SELECT uid, username FROM users WHERE uid = ?';
$statement = $connection->prepare($query);
$statement->bind_param('s', $uid);
$statement->execute();
$result = $statement->get_result();

Avec la fonction mysqli_execute_query le code est grandement simplifié.

$query = 'SELECT uid, username FROM users WHERE uid = ?';
$result = $mysqli->execute_query($sql, [$uid]);

Toutes les nouvelles fonctionnalités et changements de PHP 8.2 sont récapitulées dans ce billet.

PHP 8.1 est sorti

Soumis par fredericmazue le

Le projet PHP vient d'annoncer la disponibilité de PHP 8.1. Il s'agit d'une version majeure qui apporte de nombreuses nouvelles fonctionnalités et une importante amélioration des performances.

Enumérations

Parmi les nouveautés, nous trouvons l'arrivée des énumérations, similaires aux énumérations du langage C. Elles permettent l'écriture d'un code plus naturel et plus léger. Par exemple :

Avant PHP 8.1

class Status
{
    const DRAFT = 'draft';
    const PUBLISHED = 'published';
    const ARCHIVED = 'archived';
}
function acceptStatus(string $status) {...}

Avec PHP 8.1

enum Status
{
    case Draft;
    case Published;
    case Archived;
}
function acceptStatus(Status $status) {...}

Propriétés readonly

les propriétés en lecture seule, ou readonly d'exposer directement les propriétés publiques en lecture seule, sans craindre que les invariants de classe puissent être rompus par une modification externe. Les propriétés readonly sont initialisées une fois dans le constructeur de classe et ne peuvent plus êttre modifiées ensuite. L'exposition de propriétés publiques readonly allège le code car cela rend l'écriture d'un accesseur inutile.

Avant PHP 8.1 :

class BlogData
{
    private Status $status;

    public function __construct(Status $status)
    {
        $this->status = $status;
    }

    public function getStatus(): Status
    {
        return $this->status;   
    }
}

Avex PHP 8.1

class BlogData
{
    public readonly Status $status;

    public function __construct(Status $status)
    {
        $this->status = $status;
    }
}

La syntaxe First-class callable

L'avantage de cette nouvelle syntaxe est qu'elle permet l'analyse statique du code et qu'elle respecte la portée au moment où l'appelable est créé.

$fn = Closure::fromCallable('strlen');
$fn = strlen(...);

$fn = Closure::fromCallable([$this, 'method']);
$fn = $this->method(...)

$fn = Closure::fromCallable([Foo::class, 'method']);
$fn = Foo::method(...);

Dans l'exemple ci-dessus, chaque paire d'expressions est équivalente. La syntaxe strlen(...) crée un Closure qui fait référence à la fonction strlen(), et ainsi de suite.

Expression new dans les initialiseurs

Avec le support de new dans les initialiseurs, les objets peuvent désormais être utilisés comme valeurs de paramètres par défaut, variables statiques et constantes globales, ainsi que dans les arguments d'attribut.

Avant PHP 8.1

class Service
{
    private Logger $logger;

    public function __construct(
        ?Logger $logger = null,
    ) {
        $this->logger = $logger ?? new NullLogger();
    }
}

Avec PHP 8.1

class User
{
    #[\Assert\All(
        new \Assert\NotNull,
        new \Assert\Length(min: 6))
    ]
    public string $name = '';
}

Le type de retour never

Une fonction ou une méthode déclarée avec le type never indique qu'elle ne retournera pas de valeur et lèvera une exception ou terminera l'exécution du script avec un appel de die(), exit(), trigger_error(), ou quelque chose de similaire. Il est à remarquer que le type de retour never permet de détecter du code mort à l'analyse statique

Avant PHP 8.1

function redirect(string $uri) {
    header('Location: ' . $uri);
    exit();
}

function redirectToLoginPage() {
    redirect('/login');
    echo 'Hello'; // <- code mort ici
}

Avec PHP 8.1

function redirect(string $uri): never {
    header('Location: ' . $uri);
    exit();
}

function redirectToLoginPage(): never {
    redirect('/login');
    echo 'Hello'; // <- code mort détecté à l'analuse statique
}

Améliorations des performances

Alors que performances de PHP 7.4  et PHP 8.0 sont sensiblement équivalentes, l'équipe PHP annonce une accélération de l'exécution de 23% pour PHP 8.1, par rapport à PHP 8.0. Ceci pour la démonstration de Symfony. En revanche l'accélération de WordPress n'est que de 3.5%.

Toutes les nouveautés de PHPO 8.1 ici.

PHP Fondation : une nouvelle vie pour PHP

Soumis par francoistonic le

PHP Foundation a pour mission de continuer à gouverner le monde PHP et de poursuivre le développement du langage. C’est une étape importante dans la vie de PHP et de son futur. C’est un ancien responsable de JetBrains qui va piloter la fondation : Nikita Popov. Nikita a beaucoup oeuvré sur RUST et LLVM. 

La fondation va accueillir plusieurs grands acteurs tels que Laravel, Zend, Acquia, Symfony, JetBrains, PrestaShop, etc. JetBrains devrait être un des gros contributeurs avec 100 000 $ tous les ans. 

Au lancement, une gouvernance provisoire est mise en place le temps de constituer le conseil d’administration. On retrouvera notamment Rasmus Lerdorf. 

La fondation doit participer activement au développement du langage et de l’écosystème et proposer une roadmap claire sur les évolutions à venir. Cette vision à long terme n’était pas toujours très claire. Pour le moment, la procédure pour proposer des nouvelles fonctionnalités ne change pas. 

La fondation doit être une sécurité si un contributeur important arrête de supporter le projet. La priorité est de construire la gouvernance et de constituer le core team pour développer et maintenir le coeur du langage. 

François Tonic

Commentaire actu

Sortie de PHP 7.4.25

Soumis par fredericmazue le

Alors que PHP 8.0 continue son chemin avec une version 8.0.12 et une version 8.1.0 RC4 disponibles, le projet PHP vient de sortir PHP 7.4.25

II s'agit d'une version de sécurité qui corrige quelques problèmes dont des bugs de gestion mémoire.

Le projet PHP encourage vivement les utilisateurs de PHP 7.4 à mettre à jour vers cette version.

Mise à jour de sécurité PHP 7.4.18 et mise à jour PHP 8.0.5

Soumis par fredericmazue le

Le projet PHP vient de sortir PHP 7.4.18. Cette version n'apporte rien de nouveau mais elle est néanmoins importante car il s'agit d'une mise à jour de sécurité qui corrige également une quarantaine de bugs.

Parmi ceux-ci, certains étaient particulièrement malencontreux, notamment les bugs relatifs à PDO_ODBC et MySQLi qui tronquaient des données.

Le projet PHP a également publié PHP 8.0.5. Il s'agit cette fois d'un correctif de bugs uniquement, dont celui empêchant de charger mod_php en mode thread sur FreeBSD.

Site : php.net

Des pirates ont attaqué le code source de PHP !

Soumis par fredericmazue le

Un billet de Nikita Popov sur la liste de diffusion de PHP fait état d'une tentative de corruption du code source du langage. Dimanche 28 mars 2021, deux contributions (commits) malveillantes ont été poussées dans le dépôt de code, sous prétexte de corriger une faute de frappe.

Ces deux commits ont été poussés aux noms de Rasmus Lerdorf et de Nikita Popov, les deux noms les plus connus du projet PHP. Pour mémoire Rasmus Lerdorf est le créateur du langage.

A moment où nous écrivons ces lignes, Nikita Popov ne sait pas exactement ce qui s'est passé. Il estime que le serveur de git.php.net a été compromis. Mais que ni son compte individuel ni celui de Rasmus Lerdorf ne sont compromis.

Toutefois, au vu de cet incident, l'équipe a décidé que le maintien de sa propre infrastructure git est un risque de sécurité inutile. Le serveur de git.php.net sera donc arrêté. Les référentiels sur GitHub, qui n'étaient auparavant que des miroirs, deviendront canoniques et les modifications de code devront être transmises directement sur GitHub.

Le code malveillant injecté est donné dans deux billets sur GitHub. Ici  et ici.

Il s'agit d'une porte dérobée (backdoor) qui exécute du code à partir de l'en-tête HTTP de l'user agent s'il s'y trouve une chaîne qui commence par zerodium. Pour mémoire Zerodium est une société de sécurité informatique fondée en 2015 par Chaoui Bekrar, qui a également fondé la société française Vupen. L'activité principale officielle de Zerodium consiste à développer ainsi qu'à acquérir des exploits zero-day auprès de chercheurs en sécurité, et à rendre compte de la recherche, ainsi que des mesures de protection et des recommandations de sécurité, à ses clients gouvernementaux, 'démocratiques ou de confiance'. Dans la réalité, Zerodium est une société très controversée. Notamment, Zerodium est soupçonnée de vendre des exploits à des régimes totalitaires, afin que ceux-ci puissent espionner leurs dissidents politiques.

Le fait que le nom zerodium apparaisse dans ce code malveillant ne constitute toutefois pas une preuve que Zerodium est derrière cette attaque.

Les nouveautés de PHP 8.1

Soumis par fredericmazue le

PHP 8 est sorti mi-décembre 2020, et PHP en en cours de développement actif. Cette nouvelle mouture devrait être publiée vers la fin novembre 2021. Voici quelques-unes des nouveautés auxquelles on peut s'attendre.

Vient tout d'abord l'extraction (unpacking) de valeurs de tableau avec des clés chaîne. Cette extraction existe pour les tableaux à clés numériques depuis PHP 7.4. Avec des clés chaîne, il devient possible d'écrire ceci :

$array1 = ["a" => 1];
$array2 = ["b" => 2];
$array = ["a" => 0, ...$array1, ...$array2];
var_dump($array); // ["a" => 1, "b" => 2]

Les énumérations pourrait arriver dans PHP 8.1 (la proposition est toujours en discussion). Cela pourrait donner quelque chose comme ceci :

enum Status {
  case Pending;
  case Active;
  case Archived;
}

class Post
{
    public function __construct(
        private Status $status = Status::Pending;
    ) {}

    public function setStatus(Status $status): void
    {
        // …

    }
}

$post->setStatus(Status::Active);

Ce très intéressant billet développe l'intérêt qu'il y a à avoir des énumérations en PHP.

Avec PHP 8.1, il faut aussi s'attendre à des changements de rupture, dont un qui va sans doute casser pas mal de code. Ce changement concerne la table de symboles internes $GLOBALS. Selon l'équipe de PHP, le changement introduit aurait un impact significatif sur toutes les opérations de tableaux.

Ce changement veut que les accès à GLOBALS sans déréférencement renvoient une copie en lecture seule du tableau.

En clair, si

$GLOBALS[$une_variable] = $valeur;

reste légal, toutes les opérations comme

$GLOBALS = [];
$GLOBALS += [];
$GLOBALS =& $x;
$x =& $GLOBALS;
unset($GLOBALS);

renverront une erreur.