# Histoire de PHP : de sa création à la version actuelle 8.3

- Canonical: https://asgru.com/fr/histoire-de-php-de-sa-creation-a-la-version-actuelle-8-3/
- Language: fr
- Author: asgru
- Published: 2024-09-05T04:57:47+02:00
- Updated: 2026-09-15T13:47:51+02:00

PHP est l’un des langages de programmation les plus populaires pour le développement web. Depuis sa création en 1994, il a parcouru un long chemin, passant d’un simple outil pour les pages web dynamiques à un langage de programmation puissant, performant et polyvalent. Examinons les principales étapes de son évolution et abordons en détail les changements majeurs des versions 8.0, 8.1, 8.2 et 8.3.

### Étapes de l’évolution de PHP

#### 1995 : Naissance de PHP/FI 1.0

PHP a été créé par le programmeur danois Rasmus Lerdorf en 1994 sous la forme d’un ensemble de scripts Perl destinés à suivre les visites de son CV sur un site web. En 1995, il a publié la première version de PHP/FI (Personal Home Page/Forms Interpreter), prenant en charge les formulaires HTML et l’interaction avec les bases de données.

#### 1998 : PHP 3.0 et la révolution du langage

Avec l’aide de Zeev Suraski et Andi Gutmans, PHP a été entièrement réécrit, ce qui a conduit à la sortie de PHP 3.0 en 1998. Cette version a introduit le nouveau moteur Zend Engine, qui a considérablement amélioré les performances et la flexibilité du langage. PHP 3 est devenu la première version largement utilisée du langage à prendre en charge la programmation orientée objet.

#### 2000 : PHP 4.0 et l’apparition de Zend Engine

PHP 4 avec Zend Engine 1.0 est apparu en 2000, offrant de meilleures performances et la prise en charge des sessions, ce qui a rendu PHP plus adapté à la création d’applications web dynamiques complexes.

#### 2004 : PHP 5.0 et une nouvelle ère de la POO

PHP 5, publié en 2004, a introduit une prise en charge complète de la programmation orientée objet, une interaction améliorée avec les bases de données via PDO (PHP Data Objects) et un nouveau modèle de gestion des exceptions.

#### 2015 : PHP 7.0 et une amélioration significative des performances

En 2015, PHP 7.0 a proposé une nouvelle génération de Zend Engine 3.0, doublant la vitesse d’exécution du code et ajoutant la prise en charge du typage des arguments de fonctions et des valeurs de retour.

### PHP 8 : principales nouveautés

PHP 8.0, publié en novembre 2020, a marqué une avancée importante grâce à de nombreuses nouvelles fonctionnalités et améliorations qui ont rendu le langage plus pratique, performant et expressif. Les principales nouveautés comprennent :

#### 1. Compilation JIT (Just-in-time)

Le compilateur JIT permet de compiler dynamiquement une partie du bytecode en code machine lors de l’exécution. Cela est particulièrement utile pour les tâches nécessitant beaucoup de calculs, telles que les calculs scientifiques ou l’apprentissage automatique. Toutefois, la JIT a moins d’impact sur les applications web classiques.

Exemple :

<?php
function fibonacci($n) {
 if ($n == 0) return 0;
 if ($n == 1) return 1;
 return fibonacci($n-1) + fibonacci($n-2);
}

echo fibonacci(30);
?>

#### 2. Match Expression (correspondance de motifs)

match est une version améliorée de l’instruction switch, qui utilise un typage strict, ne nécessite pas d’instructions break et peut renvoyer directement un résultat.

Exemple d’utilisation de match :

<?php
$status = 404;

$message = match ($status) {
 200 => 'OK',
 404 => 'Not Found',
 500 => 'Internal Server Error',
 default => 'Unknown Status',
};

echo $message; // Выведет: Not Found
?>

#### 3. Arguments nommés

Les arguments nommés permettent de transmettre les paramètres des fonctions par leur nom, ce qui rend les appels de fonctions plus clairs et plus pratiques.

Exemple :

<?php
function greet(string $name, string $greeting = 'Hello') {
 echo "$greeting, $name!";
}

greet(name: 'John', greeting: 'Welcome'); // Выведет: Welcome, John!
?>

#### 4. Union Types (types d’union)

Les types d’union permettent de définir plusieurs types pour les arguments et les valeurs de retour.

Exemple :

<?php
function processInput(int|string $input) {
 if (is_int($input)) {
 return $input * 2;
 } else {
 return strtoupper($input);
 }
}

echo processInput(10); // Выведет: 20
echo processInput('hello'); // Выведет: HELLO
?>

#### 5. Constructor Property Promotion

Cette nouveauté permet d’assigner automatiquement les propriétés d’un objet à partir des arguments du constructeur, ce qui réduit le code.

Exemple :

<?php
class Point {
 public function __construct(
 public int $x,
 public int $y
 ) {}
}

$point = new Point(3, 5);
echo $point->x; // Выведет: 3
?>

#### 6. Erreurs pour les références incorrectes

PHP 8 génère des erreurs lors de l’accès à des clés de tableau ou à des propriétés d’objet inexistantes, ce qui améliore la fiabilité du code.

Exemple :

<?php
$data = [];
echo $data['key']; // Fatal Error: Uncaught Error: Undefined array key "key"
?>

### PHP 8.1 : nouveautés importantes

PHP 8.1, publié en novembre 2021, a ajouté de nombreuses fonctionnalités et améliorations importantes, telles que les énumérations, les fibres et les propriétés readonly.

#### 1. Enums (énumérations)

Les énumérations (enum) permettent de définir un ensemble fixe de valeurs utilisées dans le code.

Exemple :

<?php
enum Status {
 case Pending;
 case Completed;
 case Failed;
}

function handleStatus(Status $status) {
 return match ($status) {
 Status::Pending => 'Pending',
 Status::Completed => 'Completed',
 Status::Failed => 'Failed',
 };
}

echo handleStatus(Status::Pending); // Выведет: Pending
?>

#### 2. Fibres (Fibers)

Les fibres permettent de créer des threads coopératifs en PHP, ce qui simplifie la programmation asynchrone.

Exemple :

<?php
$fiber = new Fiber(function() {
 $value = Fiber::suspend('fiber suspended');
 echo "Resumed: $value\n";
});

echo $fiber->start(); // Выведет: fiber suspended
$fiber->resume('resume value'); // Выведет: Resumed: resume value
?>

#### 3. Readonly Properties

Les propriétés readonly ne peuvent être initialisées que lors de la création de l’objet, après quoi elles deviennent immuables.

Exemple :

<?php
class User {
 public readonly string $name;

 public function __construct(string $name) {
 $this->name = $name;
 }
}

$user = new User('Alice');
// $user->name = 'Bob'; // Ошибка, так как свойство readonly
?>

### PHP 8.2 : la poursuite des améliorations

PHP 8.2, publié en décembre 2022, a apporté des améliorations supplémentaires de la syntaxe et de nouvelles fonctionnalités.

#### 1. Classes readonly

PHP 8.2 permet de déclarer des classes comme readonly, ce qui rend automatiquement toutes leurs propriétés immuables.

Exemple :

<?php
readonly class Product {
 public function __construct(
 public string $name,
 public float $price
 ) {}
}

$product = new Product('Laptop', 1200.00);
// $product->price = 1300.00; // Ошибка, так как класс readonly
?>

#### 2. Dépréciation des propriétés dynamiques

Les propriétés dynamiques, créées en dehors de la déclaration de classe, sont désormais marquées comme obsolètes, ce qui aide à éviter les erreurs.

Exemple :

<?php
class User {}

$user = new User();
$user->name = 'John'; // Deprecated: dynamic properties are deprecated
?>

#### 3. Prise en charge de null, false et true dans les types d’union

Il est désormais possible d’indiquer null, false et true comme types dans les types d’union.

Exemple :

<?php
function test(null|false|string $value): string {
 return $value === null ? 'null' : ($value === false ? 'false' : $value);
}

echo test(null); // Выведет: null
echo test(false); // Выведет: false
echo test('test'); // Выведет: test
?>

### PHP 8.3 : les dernières améliorations

PHP 8.3, publié en novembre 2023, a poursuivi l’amélioration du langage en se concentrant sur le renforcement de la sécurité et l’ajout de nouvelles fonctionnalités utiles.

#### 1. json_validate

Une nouvelle fonction json_validate a été ajoutée ; elle permet de vérifier la validité d’une chaîne JSON sans la décoder.

Exemple :

<?php
$json = '{"name": "John", "age": 30}';
$is_valid = json_validate($json);
echo $is_valid ? 'Valid JSON' : 'Invalid JSON';
?>

#### 2. Typed Class Constants

Il est désormais possible de déclarer des types pour les constantes au sein des classes, ce qui renforce le typage.

Exemple :

<?php
class Config {
 public const string NAME = 'Application';
}

echo Config::NAME; // Выведет: Application
?>

### Conclusion

PHP 8.0 et les versions ultérieures ont apporté de nombreuses améliorations qui ont considérablement renforcé les performances et l’expressivité du langage. De la compilation JIT et des nouveautés telles que match, les types d’union et les fibres, jusqu’aux dernières améliorations de PHP 8.3, le langage continue d’évoluer et de s’adapter aux exigences des applications web modernes, tout en restant un outil essentiel pour des millions de développeurs dans le monde entier.

J’ai une excellente nouvelle pour tous mes abonnés ! 🎉 Lors du paiement des produits JetBrains, vous pouvez utiliser le code promotionnel spécial « Asgru24 » et obtenir une réduction de 25% sur n’importe quel produit ! Ne manquez pas l’occasion d’économiser sur les meilleurs outils de développement.