PHP

Pour les articles homonymes, voir PHP (homonymie).

PHP

* * *

Date de première version  | 1995[1]
Paradigmes | Impératif, orienté objet, fonctionnel, procédural, réflexif et interprété
Auteur  | Rasmus Lerdorf
Développeurs  | The PHP Group, Zend Technologies, PHP Foundation
Dernière version | 8.4.10 (3 juillet 2025)[2]
Typage  | Dynamique, Faible
Influencé par  | C, C++, Java, Perl[3]
Implémentations  | Zend Engine
Écrit en | C
Système d'exploitation | Multi-plateforme
Licence | Licence libre : Licence PHP[4]
Site web | https://www.php.net/
Extensions de fichiers | .php, .phar, .phtml, .pht, .phps
modifier

PHP: Hypertext Preprocessor[5], plus connu sous son sigle PHP (sigle auto-référentiel), est un langage de programmation libre[6], développé le 8 juin 1995 principalement utilisé pour produire des pages Web dynamiques via un serveur web[5], mais pouvant également fonctionner comme n'importe quel langage interprété de façon locale. PHP est un langage impératif orienté objet.

PHP a permis de créer un grand nombre de sites web célèbres, comme Facebook et Wikipédia[7]. Il est considéré comme une des bases de la création de sites web dits dynamiques mais également des applications web.

## Présentation

[modifier | modifier le code]

PHP est un langage de script utilisé le plus souvent côté serveur : dans cette architecture, le serveur interprète le code PHP des pages web demandées et génère du code (HTML, XHTML, CSS par exemple) et des données (JPEG, GIF, PNG par exemple) pouvant être interprétés et rendus par un navigateur web. PHP peut également générer d'autres formats comme le WML, le SVG et le PDF.

Il a été conçu pour permettre la création d'applications dynamiques, le plus souvent développées pour le Web. PHP est le plus souvent couplé à un serveur Apache bien qu'il puisse être installé sur la plupart des serveurs HTTP tels que IIS ou nginx. Ce couplage permet de récupérer des informations issues d'une base de données, d'un système de fichiers (contenu de fichiers et de l'arborescence) ou plus simplement des données envoyées par le navigateur afin d'être interprétées ou stockées pour une utilisation ultérieure.

C'est un langage peu typé et souple et donc facile à apprendre par un débutant mais, de ce fait, des bugs et des failles de sécurité peuvent rapidement apparaître dans les applications. Pragmatique, PHP ne s'encombre pas de théorie et a tendance à choisir le chemin le plus direct. Néanmoins, le nom des fonctions (ainsi que le passage des arguments) ne respecte pas une logique uniforme, ce qui peut être préjudiciable à l'apprentissage.

Son utilisation commence avec le traitement des formulaires puis par l'accès aux bases de données. L'accès aux bases de données est aisé une fois l'installation des modules correspondants effectuée sur le serveur. La force la plus évidente de ce langage est qu'il a permis au fil du temps la résolution aisée de problèmes autrefois compliqués et est devenu par conséquent un composant incontournable des offres d'hébergements.

Il est multi-plateforme : autant sur Linux qu'avec Windows il permet aisément de reconduire le même code sur un environnement à peu près semblable (quoiqu'il faille prendre en compte les règles d'arborescences de répertoires, qui peuvent changer).

Libre, gratuit, simple d'utilisation et d'installation, ce langage nécessite néanmoins une connaissance aiguë des problèmes de sécurité qui lui sont liés.

La version 5.3 a introduit de nombreuses fonctions nouvelles : les espaces de noms (Namespace) — un élément fondamental de l'élaboration d'extensions, de bibliothèques et de frameworks structurés, les fonctions anonymes, les fermetures, etc.

En 2018, près de 80 % des sites web utilisent le langage PHP sous ses différentes versions[8].

Le langage PHP fait l'objet, depuis plusieurs années maintenant, de rassemblements nationaux organisés par l'AFUP[9] (l'Association Française des Utilisateurs de PHP), où experts de la programmation et du milieu se retrouvent pour échanger autour du PHP et de ses développeurs. L'association organise ainsi deux évènements[10] majeurs : le « Forum PHP », habituellement en fin d'année, et les « AFUP Day », qui ont lieu au cours du premier semestre, simultanément dans plusieurs villes.

## Histoire

[modifier | modifier le code]

Le langage PHP a été créé en 1994 par Rasmus Lerdorf pour son site web. C'était à l'origine une bibliothèque logicielle en C[11] dont il se servait pour conserver une trace des visiteurs qui venaient consulter son CV. Au fur et à mesure qu'il ajoutait de nouvelles fonctionnalités, Rasmus a transformé la bibliothèque en une implémentation capable de communiquer avec des bases de données et de créer des applications dynamiques et simples pour le Web. Rasmus a alors décidé, en 1995, de publier son code, pour que tout le monde puisse l'utiliser et en profiter[12]. PHP s'appelait alors PHP/FI (pour Personal Home Page Tools/Form Interpreter). En 1997, deux étudiants, Andi Gutmans et Zeev Suraski, ont redéveloppé le cœur de PHP/FI. Ce travail a abouti un an plus tard à la version 3 de PHP, devenu alors PHP: Hypertext Preprocessor. Peu de temps après, Andi Gutmans et Zeev Suraski ont commencé la réécriture du moteur interne de PHP. C’est ce nouveau moteur, appelé Zend Engine — le mot Zend est la contraction de Zeev et Andi — qui a servi de base à la version 4 de PHP[13].

### Mascotte

[modifier | modifier le code]

L'elePHPant, la mascotte de PHP.

Comme de nombreux projets Open Source, PHP possède une mascotte. Il s'agit de l'elePHPant, un éléphant bleu-violet avec le logo de PHP sur son flanc[14]. Elle a été dessinée par Vincent Pontier en 1998 d'après une ressemblance des lettres "PHP" avec un éléphant lorsqu'on les regarde de coté[15].

Beaucoup de variations de cette mascotte ont été créées au fil du temps principalement sous forme d'images, mais aussi sous forme de peluches et divers goodies[16], cependant seul le design original de Vincent Pontier est considéré comme officiel par la communauté.

Le site (en-US) « A Field Guide to Elephpants » recense tous les éléPHPants existants.

### Utilisation

[modifier | modifier le code]

En 2002, PHP est utilisé par plus de 8 millions de sites Web à travers le monde[17], en 2007 par plus de 20 millions[18] et en 2013 par plus de 244 millions[19].

De plus, PHP est devenu le langage de programmation web côté serveur le plus utilisé depuis plusieurs années :

Année | Part de marché

|

2010 | 75 %
2013 | 75 %[20]
2016 | 82 %[21]
2022 | 78 %[22]

Enfin en 2010, PHP est le langage dont les logiciels open source sont les plus utilisés dans les entreprises, avec 57 % de taux de pénétration[23].

### Versions Majeures

[modifier | modifier le code]

Depuis juin 2011 et le nouveau processus de livraison de PHP[24], le cycle de livraison de PHP se résume à une mise à jour annuelle comportant des changements fonctionnels importants. La durée de vie d'une branche est de 3 ans, laissant trois branches stables et maintenues (cela signifie que lorsqu'une nouvelle version de PHP 5.x sort, la version 5.x-3 n'est plus supportée).

#### Version 8 (PHP 8)

[modifier | modifier le code]

Sortie le 26 novembre 2020, cette version majeure se démarque principalement par la fonctionnalité de « compilation à la volée » (Just-in-time compilation[25]) qui permet un gain de vitesse d'exécution de plus de 45 %[26] pour certaines applications Web. D'autres nouveautés sont également introduites comme :

* la promotion des propriétés du constructeur[27] ;
* les weakmaps[28] ;
* la Stringable Interface[29] ;
* l'expression throw[30].

#### Version 7 (PHP 7)

[modifier | modifier le code]

Au vu des orientations différentes prises par le langage de celles prévues par PHP 6, une partie des développeurs propose de nommer la version succédant à PHP 5 « PHP 7 » au lieu de « PHP 6 ». Un vote parmi les développeurs valide cette proposition par 58 voix contre 24[31].

PHP 7.0.0 est sorti en décembre 2015.

La nouvelle version propose une optimisation du code et, d'après la société Zend, offre des performances dépassant celles de machines virtuelles comme HHVM[32],[33]. Les benchmarks externes montrent des performances similaires pour HHVM et PHP 7, avec un léger avantage d'HHVM dans la plupart des scénarios[34].

#### PHP 6 et Unicode

[modifier | modifier le code]

En 2005, le projet de faire de PHP un langage fonctionnant d'origine en Unicode a été lancé par Andrei Zmievski, ceci en s'appuyant sur la bibliothèque International Components for Unicode (ICU) et en utilisant UTF-16 pour représenter les chaînes de caractères dans le moteur[35].

Étant donné que cela représentait un changement majeur tant dans le fonctionnement du langage que dans le code PHP créé par ses utilisateurs, il fut décidé d'intégrer cela dans une nouvelle version 6.0 avec d'autres fonctionnalités importantes alors en développement[36]. Toutefois, le manque de développeurs experts en Unicode ainsi que les problèmes de performance résultant de la conversion des chaînes de et vers UTF-16 (rarement utilisé dans un contexte web), ont conduit au report récurrent de la livraison de cette version[37]. Par conséquent, une version 5.3 fut créée en 2009 intégrant de nombreuses fonctionnalités non liées à Unicode qui était initialement prévues pour la version 6.0, notamment le support des espaces de nommage (namespaces) et des fonctions anonymes. En mars 2010, le projet 6.0 intégrant Unicode fut abandonné et la version 5.4 fut préparée afin d'intégrer la plupart des fonctionnalités non liées à l'Unicode encore dans la branche 6.0, telles que les traits ou l'extension des fermetures au modèle objet[38].

Le projet est depuis passé à un cycle de livraison prévisible (annuel) contenant des avancées significatives mais contenues tout en préservant au maximum la rétro-compatibilité avec le code PHP existant (5.4 en 2012, 5.5 en 2013, 5.6 prévue pour l'été 2014). Depuis janvier 2014[39], l'idée d'une nouvelle version majeure introduisant Unicode mais se basant sur UTF-8 (largement devenu depuis le standard du Web pour l'Unicode) et permettant certains changements pouvant casser la rétro-compatibilité avec du code PHP ancien est de nouveau discutée et les RFC sont maintenant triées selon leur implémentation en 5.x (évolutions ne causant pas ou marginalement de cassure de la rétro-compatibilité) ou dans la future version majeure (évolutions majeures du moteur et évolutions impliquant une non-compatibilité ascendante).

#### À noter

[modifier | modifier le code]

Il est à noter qu'historiquement, PHP disposait d'une configuration par défaut privilégiant la souplesse à la sécurité (par exemple register globals, qui a été activé par défaut jusqu'à PHP 4.2[40]). Cette souplesse a permis à de nombreux développeurs d'apprendre PHP mais le revers de la médaille a été que de nombreuses applications PHP étaient mal sécurisées. Le sujet a bien été pris en main par le PHPGroup qui a mis en place des configurations par défaut mettant l'accent sur la sécurité. Il en résultait une réputation de langage peu sécurisé, réputation d'insécurité qui n'a plus de raison d'être[réf. nécessaire].

#### Historique des versions

[modifier | modifier le code]

Un historique détaillé de toutes les versions de PHP est disponible sur cette page. Un tableau des versions supportées est aussi disponible sur le site officiel ici.

Le tableau ci dessous référence les principales versions et les changements les plus notables.

Historique des versions  Version majeure  | Version mineure  | Date de sortie  | Date de fin de support[41] | Notes

|
|
|
|

1  | Ancienne version, plus prise en charge : 1.0  | 8 juin 1995 |  | Appelé officiellement « Personal Home Page Tools (PHP Tools) », outils pour page personnelle. C'est la première apparition du nom « PHP »[42].
2  | Ancienne version, plus prise en charge : 2.0  | 12 novembre 1997 |  |
3  | Ancienne version, plus prise en charge : 3.0  | 6 juin 1998 | 20 octobre 2000  | Passage d'une personne à une équipe de développeurs. Zeev Suraski et Andi Gutmans réécrivent la base de cette version[42].
4  | Ancienne version, plus prise en charge : 4.0  | 22 mai 2000 | 23 juin 2001  | Ajout d'un système d'analyse syntaxique plus avancé appelé le Zend Engine. Ce moteur procède en deux étapes d'analyse puis d'exécution.
Ancienne version, plus prise en charge : 4.1  | 10 décembre 2001 | 12 mars 2002  | Introduit les superglobals (`$_GET`, `$_POST`, `$_SESSION`, etc.)
Ancienne version, plus prise en charge : 4.2  | 22 avril 2002 | 6 septembre 2002  | Désactive register_globals par défaut. Les données en provenance du réseau ne sont plus insérées directement dans l'espace de nom global, réduisant ainsi les possibilités de failles de sécurité
Ancienne version, plus prise en charge : 4.3  | 27 décembre 2002 | 31 mars 2005  | Introduit le CLI, en addition au CGI.
Ancienne version, plus prise en charge : 4.4  | 11 juillet 2005 | 7 août 2008  | Ajout du manuel (pages accessibles par la commande `man`) pour les scripts `phpize` et `php-config`.
5  | Ancienne version, plus prise en charge : 5.0  | 13 juillet 2004 | 5 septembre 2005  | Zend Engine II avec un nouveau modèle objet[43].
Ancienne version, plus prise en charge : 5.1  | 24 novembre 2005 | 24 août 2006  | Amélioration de performances par l'introduction de variables de compilation dans un moteur PHP repensé[43].
Ancienne version, plus prise en charge : 5.2  | 2 novembre 2006 | 6 janvier 2011  | Activation par défaut de l'extension «filter»[43].
Ancienne version, plus prise en charge : 5.3  | 30 juin 2009[44] | 14 août 2014  | Support des espaces de noms ; Late Static Bindings (résolution statique à la volée) ; étiquettes de saut (goto limité) ; fermetures (closures) ; Native PHP archives (phar) ; ramasse-miettes de références cycliques ; connexion persistante avec MySQLi, sqlite3 ; ajout de fileinfo en tant que remplacement de mime_magic pour un meilleur support de MIME ; raccourci pour l’opérateur ternaire (?:) ; fonctions anonymes ; nombreuses corrections de bogue[45]...
Ancienne version, plus prise en charge : 5.4  | 1er mars 2012 | 3 septembre 2015  | Support des traits ; syntaxe courte des tableaux introduite ; accès aux index de tableaux en sortie de fonctions ; les fermetures supportent $this ; <?= toujours disponible ; accès aux attributs d'un objet dès l'instanciation ; ajout syntaxe Class::{expr}() ; ajout format de nombres binaires ; suivi des envois de fichiers via l'extension de session ; serveur web embarqué en CLI[46] dédié au développement ; support de Dtrace ; suppression des extensions magic quotes, safe_mode, register_globals et register_long_array[46].
Ancienne version, plus prise en charge : 5.5  | 20 juin 2013 | 21 juillet 2016  | Support des générateurs et des coroutines ; ajout d'une API de hachage des mots de passe ; intégration en standard du système de cache Zend OPcache[47] ; correction de nombreux bogues ; arrêt du support de Windows XP et Windows Server 2003 ; mise à jour de la bibliothèque GD ; les fonctions mysql_ sont maintenant considérées comme obsolètes (mise en avant de mysqli_ et de PDO_MySQL).
Ancienne version, plus prise en charge : 5.6  | 28 août 2014 | 31 décembre 2018  | Nouvelle syntaxe pour les fonctions à paramètres variables et dépaquetage de paramètres, importation de fonctions au sein d'espaces de noms, intégration du débogueur phpdbg en standard, amélioration de l'extension zip, expressions acceptées pour la définition de constantes, amélioration de la gestion des données POST, support de la surcharge d'opérateurs dans le Zend Engine, nouvelle méthode magique __debugInfo() fournissant des informations de débogage sur les objets, améliorations diverses sur le support de SSL/TLS, ajout de l'opérateur d'exponentiation « `**` », téléchargements de poids supérieur à 2 Go désormais supportés.
7  | Ancienne version, plus prise en charge : 7.0  | 3 décembre 2015 | 10 janvier 2019  | Performance améliorée grâce au moteur « phpng » (jusqu'à deux fois plus rapide que PHP 5.6), support homogène des architectures 64 bits, ajout d'exceptions permettant d'intercepter des erreurs fatales, ajout des opérateurs « `??` » (dit « null coalescing (en) ») et « `<=>` » (dit « combined comparison »), possibilité de déclarer explicitement le type retourné par une fonction ainsi que les types scalaires des arguments, support des classes anonymes[48]...
Ancienne version, plus prise en charge : 7.1  | 1er décembre 2016 | 1er décembre 2019  | Types nullables (en), type de retour `void`, pseudo-type `iterable`, visibilité des constantes de classes, améliorations de `list()`, catch de plusieurs types d'exception, etc.[49]
Ancienne version, plus prise en charge : 7.2  | 30 novembre 2017[50] | 30 novembre 2020  | Ajout de l'interface `Countable`, de la constante `PHP_OS_FAMILY`, etc.
Ancienne version, plus prise en charge : 7.3  | 29 novembre 2018[51] | 6 décembre 2021  | Syntaxe Heredoc et Nowdoc plus flexibles, virgule de fin dans l’appel de fonction, `JSON_THROW_ON_ERROR`, affectation par référence avec la fonction `list()`, `is_countable()`, `array_key_first()` et `array_key_last()`, algorithme de hachage Argon2id, etc.[52]
Ancienne version, plus prise en charge : 7.4  | 28 novembre 2019 | 28 novembre 2022  | Propriétés typées 2.0, préchargement, opérateur d’affectation par coalescence nulle, `openssl_random_pseudo_bytes` peut lancer une exception, ajout des références faibles, l’extension de hash de l’interface FFI (Foreign Function Interface) est toujours obligatoire, registre des hashs de mots de passe, split sur les chaînes multi‐octets, réflexion pour les références, unbundle ext/wddx, nouveau mécanisme de sérialisation personnalisée des objets et correction de multiples bogues[53].
8  | Ancienne version, plus prise en charge : 8.0  | 26 novembre 2020[54] | 26 novembre 2023  | « Compilation à la volée » (Just-in-time compilation [25]), unions de types, type « mixed », type de retour « static », paramètres nommés, opérateur « nullsafe », mot-clé « match », ...
Ancienne version, toujours prise en charge : 8.1  | 25 novembre 2021 |  | Nouvelles fonctionnalités:

* les énumérations;
* les fibers pour créer des coroutines ;
* la propriété `readonly` pour empêcher une variable d'être modifié;

et d'autres[55].

Ancienne version, toujours prise en charge : 8.2  | 8 décembre 2022 |  | Nouvelles fonctionnalités:

* les classes en lecture seule : `readonly class` signifie que tous les arguments de son constructeur sont implicitement en `readonly`;
* les types `null`, `true` et `false`;
* les constantes dans les traits ;
* la forme normale disjonctive de type (combinaison de l'union et de l'intersection);

et d'autres[56].

Dernière version stable: 8.3 | 23 novembre 2023 |  | Nouvelles fonctionnalités:

* constantes de classe typées;
* une nouvelle fonction `json_validate()`;
* clonage en profondeur des propriétés de `readonly`;
* nouvel attribut `#[\Override]`;
* récupération dynamique des constantes de classe et des membres de l’Enum;
* nouvelle méthode `getBytesFromString()`;
* nouvelles méthodes `getFloat()` et `nextFloat()`;

et d'autres[57].

Dernière version stable: 8.4 | 21 novembre 2024 |  | Nouvelles fonctionnalités:

* propriété avec hooks;
* visibilité asymétrique des propriétés;
* objets paresseux;
* nouvel attribut `#[\Deprecated]`;
* nouveau type `BcMath\Number`;

et d'autres[58].

Légende :

Ancienne version

Ancienne version, toujours prise en charge

Dernière version stable

Dernière version avancée

Version future

## Fonctionnement

[modifier | modifier le code]

PHP appartient à la grande famille des descendants du C, dont la syntaxe est très proche. En particulier, sa syntaxe et sa construction ressemblent à celles des langages Java et Perl, à ceci près que du code PHP peut facilement être mélangé avec du code HTML au sein d'un fichier PHP.

Dans une utilisation destinée à l'internet, l'exécution du code PHP se déroule ainsi : lorsqu'un visiteur demande à consulter une page de site web, son navigateur envoie une requête au serveur HTTP correspondant. Si la page est identifiée comme un script PHP (généralement grâce à l'extension `.php`), le serveur appelle l'interprète PHP qui va traiter et générer le code final de la page (constitué généralement d'HTML ou de XHTML, mais aussi souvent de feuilles de style en cascade et de JS). Ce contenu est renvoyé au serveur HTTP, qui l'envoie finalement au client.

Ce schéma explique ce fonctionnement :

Une étape supplémentaire est souvent ajoutée : celle du dialogue entre PHP et la base de données. Classiquement, PHP ouvre une connexion au serveur de SGBD voulu, lui transmet des requêtes et en récupère le résultat, avant de fermer la connexion.

Capture d'écran de Vim en fond, affichant un script PHP, et à droite le résultat du script interprété par PHP.

L'utilisation de PHP en tant que générateur de pages Web dynamiques est la plus répandue, mais il peut aussi être utilisé comme langage de programmation ou de script en ligne de commande sans utiliser de serveur HTTP ni de navigateur. Il permet alors d'utiliser de nombreuses fonctions du langage C et plusieurs autres sans nécessiter de compilation à chaque changement du code source.

Pour réaliser en Linux/UNIX un script PHP exécutable en ligne de commande, il suffit comme en Perl ou en Bash d'insérer dans le code en première ligne le shebang : `#! /usr/bin/php`[59]. Sous un éditeur de développement comme SciTE, même en Windows, une première ligne `<?php` suffit, si le fichier possède un type .php.

Il existe aussi une extension appelée PHP-GTK permettant de créer des applications clientes graphiques sur un ordinateur disposant de la bibliothèque graphique GTK+, ou encore son alternative WinBinder.

PHP possède un grand nombre de fonctions permettant des opérations sur le système de fichiers, exécuter des commandes dans le terminal, la gestion des bases de données, des fonctions de tri et hachage, le traitement de chaînes de caractères, la génération et la modification d'images, des algorithmes de compression...

Le moteur de Wikipédia, MediaWiki, est écrit en PHP et interagit avec une base MySQL ou PostgreSQL

### Hello world

[modifier | modifier le code]

Quelques exemples du traditionnel Hello world :

<?php

echo 'Hello World';

`echo` étant une structure du langage, il est possible – et même recommandé – de ne pas mettre de parenthèses.

Il est aussi possible d'utiliser la version raccourcie :

<?= 'Hello World' ?>

Résultat affiché :

Hello World

### Balises

[modifier | modifier le code]

Le code PHP doit être inséré entre les balises `<?php` et `?>` (la balise de fermeture est facultative en fin de fichier).

Il y existe d'autres notations pour les balises :

* `<?=` et `?>` (notation courte avec affichage) ;
* `<?` et `?>` (notation courte sans affichage non disponible en PHP 8) ;
* `<%` et `%>` (notation ASP) ;
* `<script language="php">` et `</script>` (notation script).

Les notations autres que la standard (`<?php` et `?>)` et la notation courte avec affichage (`<?=` et `?>)` sont déconseillées, car elles peuvent être désactivées dans la configuration du serveur (php.ini ou .htaccess) : la portabilité du code est ainsi réduite.

Depuis PHP 7, les notations ASP et script ont été supprimées[60]. La notation courte sans affichage reste déconseillée.

### Instructions

[modifier | modifier le code]

Les instructions sont séparées par des `;` (il n'est pas obligatoire après la dernière instruction) et les sauts de ligne ne modifient pas le fonctionnement du programme. Il serait donc possible d'écrire :

<?php echo 'Hello World'; echo 'Comment allez-vous ?'; echo 'Il fait beau non ?' ?>

Pour des raisons de lisibilité, il est néanmoins recommandé d'écrire une seule instruction par ligne. Il est aussi préférable d'écrire le dernier `;`.

### Structures de contrôle

[modifier | modifier le code]

Le code PHP est composé par des appels à des fonctions, dans le but d'attribuer des valeurs à des variables, le tout encadré dans des conditions, des boucles. Exemple :

<?php

// la fonction strtolower renvoie en minuscules la chaîne de caractères passée en paramètre
$lang = strtolower($_POST['lang']);

if ($lang === 'fr') {
echo 'Vous parlez français !';
} elseif ($lang === 'en') {
echo 'You speak English!';
} else {
echo 'Je ne vois pas quelle est votre langue !';

Une condition est appliquée quand l'expression entre parenthèses est évaluée à `true`, et elle ne l'est pas dans le cas de `false`. Sous forme numérique, `0` représente le `false`, et `1` (et tous les autres nombres) représentent le `true`.

Le code précédent pourrait aussi être écrit de cette manière :

<?php

$lang = strtolower($_POST['lang']);
$isLangFr = $lang === 'fr';
$isLangEn = $lang === 'en';

if ($isLangFr) {
echo 'Vous parlez français !';
} elseif ($isLangEn) {
echo 'You speak English!';
} else {
echo 'Je ne vois pas quelle est votre langue !';

Ici on teste l'égalité entre `$lang` et `'fr'`, mais pas directement dans le `if` : le test retourne un boolean (c'est-à-dire soit `true`, soit `false`) qui est stocké dans la variable `$is_lang_fr`. On entre ensuite cette variable dans le `if` et celui-ci, selon la valeur de la variable, effectuera ou non le traitement.

Les blocs `if`, `elseif` et `else` sont généralement délimités par les caractères `{` et `}`, qui peuvent être omis, comme dans les codes précédents, lorsque ces blocs ne contiennent qu'une instruction.

Il est également possible d'écrire `else if` en deux mots, comme en C/C++.

### Génération de code HTML

[modifier | modifier le code]

On peut générer du code HTML avec le script PHP, par exemple :

<?php

$nom = 'Albert';
echo '<div>Bonjour ' . $nom . ' !</div>';

Il est également possible d'utiliser une syntaxe alternative pour la structure if/else :

<?php

$nomsAutorises = [ 'Albert', 'Bertrand' ];
$nomEnCours = 'Eve';

<?php if (in_array($nomEnCours, $nomsAutorises)): ?>
<p>Bonjour <?php echo $nomEnCours; ?> !</p>
<?php else: ?>
<p>Vous n'êtes pas un utilisateur autorisé !</p>
<?php endif; ?>

Une autre approche consiste à concaténer l'intégralité du code HTML dans une variable et de réaliser un echo de la variable en fin de fichier :

<?php

$out = '';

// On ajoute progressivement tout le code html
$out .= '<p>a' . 'b' . 'c</p>';
$out .= '<div class="bottom"><p>d' . 'e' . 'f</p></div>';

// On affiche le contenu
echo $out;

Dans le cas où l'utilisateur aura préféré l'utilisation de la commande `echo` à la concaténation, il lui sera possible de capturer le flux en utilisant les fonctions `ob_start()` et `ob_get_clean()` :

<?php

// On place le flux dans un tampon
ob_start();

// On fait des affichages
echo 'abc' . "\n";
echo 'def' . "\n";
require_once 'fichier.php'; // De nombreux affichages (echo)

// On stoppe la mise en tampon, on récupère son contenu et on met le tampon à vide (pour une éventuelle prochaine tamporisation)
$out = ob_get_clean();

// On affiche le contenu du tampon
echo $out;

PHP, tout comme JavaScript, permet aussi de construire un modèle objet de document (DOM)[61], ce qui permet de créer ou modifier un document (X)HTML sans écrire de HTML, comme le montre l'exemple suivant :

<?php

$doctype = DOMImplementation::createDocumentType('html');
$dom = DOMImplementation::createDocument(null, 'html', $doctype);
$html = $dom->documentElement;
$html->head = $dom->createElement('head');
$html->appendChild($html->head);
$html->head->title = $dom->createElement('title');
$html->head->title->nodeValue = 'Exemple de HTML';
$html->head->appendChild($html->head->title);
$html->head->charset = $dom->createElement('meta');
$html->head->charset->setAttribute('http-equiv', 'Content-Type');
$html->head->charset->setAttribute('content', 'text/html; charset=utf-8');
$html->head->appendChild($html->head->charset);
$html->body = $dom->createElement('body');
$html->appendChild($html->body);
$html->body->p = $dom->createElement('p');
$html->body->p->nodeValue = 'Ceci est un paragraphe.';
$html->body->appendChild($html->body->p);
$html->body->p->br = $dom->createElement('br');
$html->body->p->appendChild($html->body->p->br);
$html->body->p->a = $dom->createElement('a');
$html->body->p->a->nodeValue = 'Ceci est un lien.';
$html->body->p->a->setAttribute('href', 'cible.html');
$html->body->p->appendChild($html->body->p->a);

echo $dom->saveHTML();

Qui crée le code HTML suivant :

<!DOCTYPE html>
<html>
<head>
<title>Exemple de HTML</title>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
</head>
<body><p>Ceci est un paragraphe.<br><a href="cible.html">Ceci est un lien.</a></p></body>
</html>

Cette méthode est cependant peu utilisée pour générer un document complet, on l'utilise généralement pour générer un fichier XML.

La commande `phpinfo()` est aussi utilisée pour générer un code HTML décrivant les paramètres du serveur ; elle est aussi très utilisée pour tester la bonne exécution du moteur d’exécution PHP.

### Programmation orientée objet

[modifier | modifier le code]

Comme en C++ et en Java, PHP permet de programmer en orienté objet, en créant des classes contenant des attributs et des méthodes, qui peuvent être instanciées ou utilisées en statique.

Toutefois, PHP est un langage à héritage simple[62], c'est-à-dire qu'une classe ne peut hériter que d'au plus une seule autre classe (sinon il faut utiliser un trait pour simuler l'héritage multiple par composition). Cependant les interfaces peuvent en étendre plusieurs autres[63].

Voici un exemple de création d'une classe :

<?php

interface EtreVivant

// Cette méthode devra être déclarée dans les classes implémentant cette interface.
public function isDead(): bool;

class Perso implements EtreVivant

public const int PV_INITIAL = 2000;

private int $pv = 0;

// Constructeur : celui-ci est appelé lors de l'instanciation de l'objet.
// Ce constructeur possède un paramètre optionnel.
public function __construct(int $pv = 0)

if ($pv < 0 || $pv > 100000000) {
$this->pv = self::PV_INITIAL;
} else {
$this->pv = $pv;

// Accesseurs
public function getPv(): int

return $this->pv;

// Implémentation de la méthode de l'interface.
public function isDead(): bool

return $this->pv === 0;

// Création d'une classe enfant de Perso
class Magicien extends Perso

private int $mana;

// Création d'une instance de classe
$mage = new Magicien(1000);

// Utilisation de l'objet
echo 'Votre mage a ' . $mage->getPv() . ' PV.';

// Constantes de classes
echo 'Le PV par défaut attribué à un nouveau personnage est de ' . Perso::PV_INITIAL . '.';

// Destruction de l'objet
unset($mage);

## Exemples d'application

[modifier | modifier le code]

* Encyclopédie (Wiki, MediaWiki, DokuWiki, etc.)
* Forum (phpBB, Vanilla, IPB, punBB, etc.)
* Réseau social (Facebook, etc.)
* Systèmes de gestion de blog (Dotclear, etc.)
* Systèmes de gestion de contenu (appelés aussi CMS) (WordPress, Drupal, Joomla, etc.)
* Administration de bases de données (phpMyAdmin, phpPgAdmin, Adminer, etc.)
* Frameworks (Laravel, Symfony, CodeIgniter, etc.)
* Logiciel ECM
* Logiciel BPM, CRM et ou ERP (Dolibarr, etc.)
* E-commerce (PrestaShop, WooCommerce, Magento, etc.)

## Plateformes

[modifier | modifier le code]

Application XAMPP sur Windows

Un serveur Web en architecture trois tiers est composé d'un système d'exploitation, un serveur HTTP, un langage serveur et enfin un système de gestion de base de données (SGBD), cela constituant une plate-forme.

Dans le cas de PHP comme langage serveur, les combinaisons les plus courantes sont celles d'une plateforme LAMP (pour Linux Apache MySQL PHP) et WAMP (Windows Apache MySQL PHP). Une plate-forme WAMP s'installe généralement par le biais d'un seul logiciel qui intègre Apache, MySQL et PHP, par exemple EasyPHP, VertrigoServ, WampServer ou UwAmp. Il existe le même type de logiciels pour les plates-formes MAMP (Mac OS Apache MySQL PHP), à l'exemple du logiciel MAMP.

Il existe d'autres variantes, par exemple les plates-formes LAPP (le M de MySQL est remplacé par le P de PostgreSQL) ou encore le logiciel XAMPP (Apache MySQL Perl PHP ; le X indique que le logiciel est multiplate-forme), un kit de développement multiplate-forme.

On peut décliner une grande variété d'acronymes sous cette forme. Des confusions peuvent parfois exister entre la plate-forme en elle-même et le logiciel permettant de l'installer, si elles ont le même nom. Il faut également remarquer que la grande majorité des logiciels « tout en un » sont destinés au développement d'applications Web en local, et non à être installés sur des serveurs Web. Une exception à cette règle est peut-être Zend Server, le serveur distribué par Zend Technologies, qui est prévu pour fonctionner aussi bien en environnement de développement que de production.

## Accélération

[modifier | modifier le code]

PHP est à la base un langage interprété, ce qui est au détriment de la vitesse d'exécution du code. Sa forte popularité associée à son utilisation sur des sites Web à très fort trafic (Yahoo, Facebook[64]) ont amené un certain nombre de personnes à chercher à améliorer ses performances pour pouvoir servir un plus grand nombre d'utilisateurs de ces sites Web sans nécessiter l'achat de nouveaux serveurs.

La réécriture du cœur de PHP, qui a abouti au Zend Engine pour PHP 4 puis au Zend Engine 2 pour PHP 5, est une optimisation. Le Zend Engine compile en interne le code PHP en bytecode exécuté par une machine virtuelle. Les projets open source APC et eAccelerator fonctionnent en mettant le bytecode produit par Zend Engine en cache afin d'éviter à PHP de charger et d'analyser les scripts à chaque requête. À partir de la version 5.5 de PHP, le langage dispose d'un cache d'opcode natif (appelé OpCache) rendant obsolète le module APC.

Il existe également des projets pour compiler du code PHP :

* Roadsend et phc compilent du PHP en C ;
* Quercus compile du PHP en bytecode Java exécutable sur une machine virtuelle Java ;
* Phalanger compile du PHP en Common Intermediate Language exécutable sur le Common Language Runtime du framework .NET ;
* HipHop for PHP transforme du PHP en C++ qui est ensuite compilé en code natif.

## Notes et références

[modifier | modifier le code]

1. ↑ « Histoire de php ».
2. ↑ a et b « PHP 8.4.10 Released! », 3 juillet 2025 (consulté le 3 juillet 2025)
3. ↑ « PHP: Préface - Manual », sur php.net.
4. ↑ « Licence du langage PHP ».
5. ↑ a et b « Manuel PHP : Préface », sur PHP.net (consulté le 7 novembre 2007).
6. ↑ (en) « La licence de PHP est reconnue libre par la Free Software Foundation » (consulté le 7 novembre 2007).
7. ↑ « Introduction à PHP », sur openclassrooms.com (consulté le 14 juillet 2015).
8. ↑ « PHP is dead…Viva le PHP! – Hacker Noon », 26 octobre 2018.
9. ↑ « Afup - Association française des utilisateurs de PHP », sur afup.org (consulté le 29 novembre 2018).
10. ↑ « AFUP Day 2019 », sur event.afup.org (consulté le 29 novembre 2018).
11. ↑ Rasmus Lerdorf, « I wonder why people keep writing that PHP was ever written in Perl. It never was. #php » [html], Twitter, 20 juillet 2012 (consulté le 5 septembre 2014).
12. ↑ « Google Groups », sur groups.google.com.
13. ↑ « Histoire de PHP », sur PHP.net (consulté le 7 novembre 2007).
14. ↑ « PHP: ElePHPant », sur www.php.net (consulté le 24 décembre 2024)
15. ↑ (en-US) Khayrattee Wasseem, « How & Why Did The PHP Mascot Come To Birth? The elePHPant Secret Story! - 7PHP », sur https://7php.com/, 4 juin 2020 (consulté le 24 décembre 2024)
16. ↑ (en) « Page Flickr officielle », sur Flickr
17. ↑ (en) « Netcraft web Server Survey - février 2002 » (consulté le 7 novembre 2007).
18. ↑ « PHP: PHP Usage Stats », sur php.net.
19. ↑ « PHP just grows & grows - Netcraft », sur news.netcraft.com.
20. ↑ « Server-side programming language statistics », 6 mars 2013.
21. ↑ « Server-side Programming Languages », w3techs, 28 avril 2016.
22. ↑ « Server-side Programming Languages », w3techs, 11 décembre 2022.
23. ↑ « PHP and Perl crashing the enterprise party ».
24. ↑ « PHP: rfc:releaseprocess », sur wiki.php.net.
25. ↑ a et b « PHP: rfc:jit », sur wiki.php.net (consulté le 5 avril 2019).
26. ↑ « PHP 8 : toutes les infos sur la nouvelle version », sur IONOS Digitalguide (consulté le 21 décembre 2021).
27. ↑ « Constructeurs et destructeurs » (consulté le 3 avril 2024).
28. ↑ « PHP: rfc:weak_maps », sur wiki.php.net (consulté le 21 décembre 2021).
29. ↑ « PHP: rfc:stringable », sur wiki.php.net (consulté le 21 décembre 2021).
30. ↑ « PHP: rfc:throw_expression », sur wiki.php.net (consulté le 21 décembre 2021).
31. ↑ Andrea Faulds, Zeev Suraski, « PHP RFC: Name of Next Release of PHP », 2004 (consulté le 22 novembre 2014).
32. ↑ « PHP Next Generation is outperforming Facebook’s HHVM », sur The Zend Blog, 17 juillet 2014 (consulté le 22 novembre 2014).
33. ↑ Antoine Crochet-Damais, « Andi Gutmans (Zend Technologies) : "PHP Next Generation est plus performant que HHVM de Facebook" », sur Le Journal du Net, 25 juin 2014 (consulté le 22 novembre 2014).
34. ↑ Zeev Suraski, « Benchmarking PHPNG! », sur Zeev's blog, juillet 2014 (consulté le 22 novembre 2014).
35. ↑ (en) Andrei Zmievski, « PHP Unicode support design document (mailing list post) », 10 août 2005 (consulté le 9 février 2014).
36. ↑ (en) « PHP 5.5 or 6.0 » (consulté le 9 février 2014).
37. ↑ (en) Andrei Zmievski, « The Good, the Bad, and the Ugly: What Happened to Unicode and PHP 6 » (consulté le 9 février 2014).
38. ↑ (en) Rasmus Lerdorf, « PHP 6 (mailing list post) », 11 mars 2010 (consulté le 7 février 2014).
39. ↑ (en) Adam Harvey, « Ruminations on PHP 5++ (message de liste de discussion) », 11 mars 2010 (consulté le 7 février 2014).
40. ↑ « Register Globals ».
41. ↑ (en) « Unsupported Branches » (consulté le 26 avril 2025)
42. ↑ a et b (en) « History of PHP », The PHP Group (consulté le 18 juin 2010).
43. ↑ a b et c (en) « PHP: PHP 5 ChangeLog », The PHP Group, 8 novembre 2007 (consulté le 22 février 2008).
44. ↑ (en) PHP 5.3.0 Released!
45. ↑ (en) PHP 5.3.0 Changelog
46. ↑ a et b « PHP: Serveur web interne - Manual », sur php.net.
47. ↑ (en) PHP 5.5.0 released.
48. ↑ (en) PHP 7.0.0 Released
49. ↑ (en) PHP 7.1.0 Released
50. ↑ (en) [1]
51. ↑ (en) « PHP 7.3.x changeLogs », sur php.net (consulté le 21 mai 2020).
52. ↑ « Nouveautés de PHP 7.3 – CODE|DESIGN•fr », sur codedesign.fr (consulté le 15 septembre 2018).
53. ↑ (en) « PHP 7.4.x changeLogs », sur php.net (consulté le 23 décembre 2019).
54. ↑ « PHP: todo:php80 », sur wiki.php.net (consulté le 16 juin 2020).
55. ↑ « PHP: PHP 8.1.0 Release Announcement », sur www.php.net (consulté le 29 décembre 2024)
56. ↑ « PHP: PHP 8.2.0 Release Announcement », sur www.php.net (consulté le 29 décembre 2024)
57. ↑ « PHP: PHP 8.3.0 Release Announcement », sur www.php.net (consulté le 29 décembre 2024)
58. ↑ « PHP: PHP 8.4 Release Announcement », sur www.php.net (consulté le 29 décembre 2024)
59. ↑ `/usr/bin/` est le répertoire standard des fichiers binaires exécutables sur la plupart des distributions.
60. ↑ (en) « PHP RFC: Remove alternative PHP tags ».
61. ↑ « PHP: DOM - Manual », sur php.net.
62. ↑ Sébastien Rohaut, Algorithmique : Techniques fondamentales de programmation (avec des exemples en PHP), Editions ENI, 2009 (lire en ligne)
63. ↑ « PHP: Interfaces - Manual », sur php.net.
64. ↑ « Facebook looks to fix PHP performance with HipHop virtual machine ».

## Annexes

[modifier | modifier le code]

Sur les autres projets Wikimedia :

* PHP, sur Wikimedia Commons
* PHP, sur le Wiktionnaire
* PHP, sur Wikiversity
* PHP, sur Wikibooks

### Bibliographie

[modifier | modifier le code]

* (en) Luke Welling et Laura Thomson, PHP and MySQL Web development, Sams Publishing, 2008, 4e éd. (ISBN 978-0-672-32916-6 et 0-672-32916-6, OCLC 854795897)
* Damien Seguy et Philippe Gamache, Sécurité PHP 5 et MySQL, 3e édition, Eyrolles, 1er décembre 2011, 277 p. (ISBN 978-2-212-13339-4 et 2-212-13339-1, lire en ligne)
* Jean Engels PHP 5 Cours et Exercices, 3e édition, Eyrolles 2013, 631 pages (ISBN 978-2-212-13725-5)

### Articles connexes

[modifier | modifier le code]

* Paamayim Nekudotayim : nom de l'opérateur `::` en PHP
* Liste de frameworks PHP : liste des cadres de développement (Frameworks) en PHP
* Suhosin: module de durcissement de PHP5
* W3Schools : site d'apprentissage de divers langages de programmation dont PHP.

### Liens externes

[modifier | modifier le code]

* (en) Site officiel

v · m

Langages de programmation

Concurrents |

* Ada
* Erlang
* Go
* Modula-2

Déclaratifs |

* Clips
* Prolog
* Mercury

Fonctionnels |

* Clojure
* Common Lisp
* Erlang
* F#
* Gallina
* Haskell
* Lisp
* ML
* OCaml
* Opa
* Scheme
* Standard ML

Impératifs |

* Algol
* APL
* Assembleur
* Basic
* BCPL
* C
* Cobol
* DOPE
* Forth
* Fortran
* Julia
* Limbo
* Lua
* Modula-2
* MUMPS
* Natural
* NQC
* NXC
* OPL
* Pascal
* Perl
* PL/I
* RPG
* PowerShell
* Rust
* Tcl
* WLangage

Orientés objet |

* ActionScript
* AppleScript
* C++
* C#
* CoffeeScript
* D
* Delphi
* Eiffel
* Groovy
* Haxe
* Java
* JavaScript
* Lisaac
* Logo
* Objective-C
* PHP
* Python
* Ruby
* Scala
* Scratch
* Simula
* Smalltalk
* Swift
* Kotlin
* Visual Basic

* Liste de langages de programmation

v · m

PHP

Personnalités |

* Andi Gutmans
* Rasmus Lerdorf
* Zeev Suraski

Ressources |

* Accélérateur (Alternative PHP Cache, eAccelerator (en), MMCache (en))
* Composer
* Éditeurs (en)
* Extensions (en)
* PHPDoc

Implémentations |

* HipHop Virtual Machine (en) (HHVM)
* HipHop for PHP
* Parrot
* Phalanger
* Quercus
* Zend Engine

Frameworks web |

* CakePHP
* CodeIgniter
* Drupal
* eZ Publish
* Fat-Free
* FuelPHP
* Horde
* Joomla!
* Laravel
* Lithium
* Midgard
* MODx
* Nette Framework
* PEAR
* Phalcon
* PRADO
* QCodo
* Silex
* SilverStripe
* Symfony
* TYPO3
* WordPress
* Xaraya
* Xoops
* Yii
* Zend Framework
* Zeta Components

Test |

* Behat
* PHPUnit
* SimpleTest
* Lime (Symfony)

Mapping objet-relationnel |

* Doctrine
* Propel

Environnement de développement |

* Aptana
* Codelobster
* Eclipse PDT
* NetBeans
* PHPEdit
* PhpStorm
* RadPHP
* Zend Studio

Toolkit |

* PHP-GTK
* PHP-Qt
* wxPHP

v · m

API Web

Côté serveur |  | Protocole de communication |

* CGI
* SCGI
* FCGI
* AJP
* WSRP
* WebSocket

|

APIs serveur |

* C NSAPI (en)
* C ASAPI
* C ISAPI
* COM ASP
* Servlet
* container
* CLI OWIN (en)
* ASP.NET Handler (en)
* Python WSGI
* Ruby Rack
* JavaScript JSGI (en)
* Perl PSGI
* Portlet container

Modules apaches |

* mod_jk
* mod_lisp (en)
* mod_mono (en)
* mod_parrot (en)
* mod_perl
* mod_php
* mod_proxy (en)
* mod_python (en)
* mod_wsgi
* mod_ruby (en)
* Phusion Passenger

Sujets |

* Ressource du World Wide Web vs. Service web
* Open API (en)
* Webhook
* Serveur d'applications
* Scripting

Côté client |  | W3C |

* HTML5 audio (en)
* Canvas
* CORS
* DOM
* DOM events (en)
* File (en)
* Geolocation (en)
* IndexedDB
* SSE
* SVG
* Video
* WebRTC
* WebSocket
* Web messaging (en)
* Stockage web local
* WebAuthn
* Web worker (en)
* XMLHttpRequest

|

Khronos |

* OpenCL
* WebGL

Autres |

* Gears
* Web SQL Database (formerly W3C)

Sujets |

* Page web dynamique
* Open Web Platform (en)
* Rich Internet application

v · m

Langages serveurs

Compilés |

* C
* Pascal
* Fortran
* Go
* Python

Interprété |

* Perl
* Python
* shell
* PHP
* ColdFusion
* ASP

Les deux |

* JavaScript
* Ruby

* Portail des logiciels libres
* Portail de la programmation informatique

*[(en-US)]: Langue : anglais américain
*[1er]: premier
*[Go]: gigaoctet
*[etc.]: et cetera
*[(en)]: Langue : anglais
*[[html]]: Fichier au format Hypertext Markup Language (HTML)
*[4e]: quatrième
*[éd.]: édition
*[3e]: Troisième
*[p.]: pages
*[v]: Voir ce modèle.
*[m]: Modifier ce modèle. Merci de prévisualiser avant de sauvegarder.