Référence : Superglobales

Lorsqu’une requête HTTP atteint une application PHP, le serveur doit répondre à trois questions :

1. Que demande le client ?
2. Quelles données a-t-il envoyées ?
3. Quelle réponse faut-il produire ?

PHP met une partie de ces informations à disposition dans des tableaux associatifs appelés superglobales.

Avant de commencer

On s’appuie sur les formulaires et la validation ($_GET, $_POST, REQUEST_METHOD) ainsi que sur les mécanismes de navigation et composition vue dans le chapitre sur les pages dynamique (include, gabarit et routeur).

Une requête HTTP vue par PHP

Une requête HTTP se compose de plusieurs parties, chacune avec un rôle précis :

• la ligne de requête : la méthode (l’action demandée), la cible (l’adresse de la ressource et ses paramètres) et la version du protocole ;
• les en-têtes : des métadonnées sur la requête, comme l’hôte visé, le format du corps ou le format de réponse attendu ;
• une ligne vide, qui sépare les en-têtes du corps ;
• un corps facultatif : les données envoyées, par exemple les champs d’un formulaire ou un document JSON.

Une requête POST se présente par exemple ainsi :

POST /index.php?page=commande HTTP/1.1
Host: localhost
Content-Type: application/x-www-form-urlencoded

nom=Ti-Jean&quantite=3

PHP rend ces informations accessibles dans des tableaux disponibles dans tous les fichiers et toutes les fonctions, sans déclaration préalable : les superglobales. Chaque partie de la requête se retrouve ainsi exposée.

Composante de la requête	Rôle	Exposée par PHP dans
Méthode	L’action demandée (GET, POST…).	$_SERVER['REQUEST_METHOD']
Cible (URL)	La ressource visée et ses paramètres.	$_SERVER['REQUEST_URI'], $_GET
En-têtes	Des métadonnées sur la requête.	$_SERVER (clés HTTP_*)
Corps	Les données envoyées.	$_POST, php://input

Ce chapitre détaille les trois superglobales les plus courantes, $_GET, $_POST et $_SERVER, avant d’en présenter quelques autres.

La superglobale $_GET

Construction. PHP remplit $_GET à partir de la chaîne de requête, c’est-à-dire la portion de l’URL située après le ?. Chaque paramètre s’écrit sous la forme nom=valeur, et le caractère & sépare les paramètres entre eux.

Pour la requête suivante :

GET /index.php?page=produits&categorie=sirop

PHP construit le tableau :

<?php
echo $_GET['page'];       // "produits"
echo $_GET['categorie'];  // "sirop"

Fonctionnement. $_GET est un tableau associatif : chaque clé est le nom d’un paramètre, et chaque valeur est son contenu, toujours sous forme de chaîne de caractères (ou de tableau, voir plus bas).

Usage. On lit une valeur par sa clé, en prévoyant le cas où le paramètre est absent grâce à l’opérateur ?? :

<?php
$categorie = $_GET['categorie'] ?? null;

Une valeur peut aussi être un tableau lorsqu’un paramètre se répète avec la notation [] :

GET /index.php?categorie[]=sirop&categorie[]=miel

<?php
$_GET['categorie']; // ["sirop", "miel"]

C’est pourquoi une vérification du type est souvent utile avant d’utiliser la valeur :

<?php
$categorie = $_GET['categorie'] ?? null;

if ($categorie !== null && !is_string($categorie)) {
    $categorie = null;
}

$_GET contient les paramètres de l’URL, indépendamment de la méthode HTTP. Une requête POST qui possède une chaîne de requête remplit elle aussi $_GET.

La superglobale $_POST

Construction. PHP remplit $_POST à partir du corps d’une requête POST, lorsque ce corps provient d’un formulaire HTML. La clé de chaque valeur est l’attribut name du champ.

<form method="post" action="index.php?page=commande">
    <input type="text" name="nom">
    <input type="email" name="courriel">
    <button>Envoyer</button>
</form>

Après l’envoi, PHP construit :

<?php
echo $_POST['nom'];       // la valeur saisie dans le champ « nom »
echo $_POST['courriel'];  // la valeur saisie dans le champ « courriel »

Fonctionnement. Comme $_GET, $_POST est un tableau associatif dont les clés sont les noms des champs. Un champ sans attribut name n’apparaît jamais dans $_POST.

Usage. On lit les valeurs de la même façon, avec une valeur par défaut et une validation :

<?php
$nom = trim($_POST['nom'] ?? '');

if ($nom === '') {
    // Champ obligatoire manquant.
}

Pour une requête GET, $_POST est vide. C’est la requête POST, et elle seule, qui le remplit à partir de son corps.

La superglobale $_SERVER

Construction. Le serveur web et PHP remplissent $_SERVER avec des informations sur la requête et sur l’environnement d’exécution. À la différence de $_GET et $_POST, ses clés sont prédéfinies : on ne les invente pas, on les consulte.

Clé	Contenu
REQUEST_METHOD	La méthode HTTP de la requête (GET, POST…).
REQUEST_URI	Le chemin demandé, avec la chaîne de requête.
QUERY_STRING	La chaîne de requête seule, sans le ?.
HTTP_HOST	Le nom d’hôte demandé par le client.
REMOTE_ADDR	L’adresse IP du client.

Fonctionnement et usage. On lit une information par sa clé :

<?php
echo $_SERVER['REQUEST_METHOD'];  // "GET"
echo $_SERVER['REQUEST_URI'];     // "/index.php?page=produits&categorie=sirop"

Certaines valeurs de $_SERVER proviennent du client, comme HTTP_HOST ou les en-têtes transmis par le navigateur. Elles ne sont pas plus fiables que $_GET ou $_POST et doivent être traitées avec la même prudence.

La méthode de la requête

La méthode HTTP, lue dans $_SERVER['REQUEST_METHOD'], indique le type d’action demandé par le client.

Méthode	Intention habituelle	Propriété importante
GET	Consulter une ressource.	Sûre et idempotente.
POST	Soumettre des données ou créer une ressource.	Généralement non idempotente.
PUT	Créer ou remplacer complètement une ressource.	Idempotente.
PATCH	Modifier partiellement une ressource.	Pas nécessairement idempotente.
DELETE	Supprimer une ressource.	Idempotente.

Sûre et idempotente

Une méthode est dite sûre lorsque le client ne demande pas de modification de l’état du système.

Une méthode est idempotente lorsque répéter plusieurs fois la même requête produit le même effet qu’une seule exécution. Supprimer deux fois la même ressource, par exemple, la laisse simplement supprimée.

On s’en sert pour distinguer l’affichage du traitement dans une même page :

<?php
$methode = $_SERVER['REQUEST_METHOD'];

if ($methode === 'POST') {
    // Traiter les données soumises.
} else {
    // Afficher la ressource ou le formulaire.
}

Les formulaires HTML prennent directement en charge GET et POST. Les autres méthodes (PUT, PATCH, DELETE) sont généralement envoyées par du JavaScript, une application mobile ou un outil comme curl.

VérificationUne requête POST peut-elle contenir des données dans $_GET ?

Oui. $_GET correspond aux paramètres de la chaîne de requête, pas à la méthode HTTP.

Une requête comme POST /index.php?page=commande place commande dans $_GET['page'], tandis que les champs du formulaire sont placés dans $_POST.

Les autres superglobales

Les trois superglobales précédentes suffisent à la plupart des pages. PHP en fournit cependant d’autres, qu’il est utile de connaître.

$_REQUEST

Construction. PHP remplit $_REQUEST en fusionnant $_GET, $_POST et $_COOKIE.

Fonctionnement et usage. On y lit une valeur sans se soucier de sa provenance :

<?php
$page = $_REQUEST['page'] ?? 'accueil';

Cette commodité a un revers : l’origine de la donnée devient ambiguë, et deux sources peuvent porter la même clé. Pour la clarté et la sécurité, on désigne plutôt la superglobale précise, $_GET ou $_POST, selon ce que l’on attend.

$_REQUEST mélange plusieurs sources. Préférez $_GET ou $_POST pour savoir exactement d’où provient une donnée.

$GLOBALS

Construction et fonctionnement. $GLOBALS donne accès à toutes les variables de la portée globale, depuis n’importe quel endroit du code, y compris l’intérieur d’une fonction. C’est la seule superglobale dont le nom ne commence pas par un tiret bas.

<?php
$tva = 0.09975;

function afficherTaux(): void
{
    echo $GLOBALS['tva']; // lit la variable globale $tva
}

Usage. Son rôle diffère des autres : il ne concerne pas la requête, mais la portée des variables. On l’évite en pratique, car il contourne l’isolation des fonctions. Passer les valeurs en paramètres, puis les retourner, reste plus clair et plus sûr.

Des superglobales vues plus tard

Trois autres superglobales relèvent de sujets à venir. Elles sont mentionnées ici pour compléter la famille.

Superglobale	Rôle
$_SESSION	Conserver des données d’une requête à l’autre pour un même visiteur.
$_COOKIE	Lire les témoins déposés dans le navigateur et renvoyés à chaque requête.
$_FILES	Accéder aux fichiers téléversés par un formulaire.

Ces trois superglobales seront développées dans un chapitre ultérieur.

Récapitulatif

• $_GET contient les paramètres de la chaîne de requête, quelle que soit la méthode HTTP.
• $_POST contient les données des formulaires envoyés avec POST ; il est vide pour une requête GET.
• $_SERVER contient des informations sur la requête et l’environnement, avec des clés prédéfinies comme REQUEST_METHOD.
• Toute donnée provenant du client doit être validée avant son utilisation, puis échappée à l’affichage.
• GET consulte, POST envoie, PUT remplace et DELETE supprime ; des outils comme Bruno, Postman ou curl permettent de tester ces requêtes.

Quiz

Quiz. Quelle superglobale contient la méthode HTTP de la requête ?

• $_GET['method']
• $_SERVER['REQUEST_METHOD']
• $_POST['verbe']

Quiz. Une requête POST contient ?categorie=sirop dans son URL. Où PHP place-t-il cette valeur ?

• Dans $_GET['categorie']
• Dans $_POST['categorie']
• Uniquement dans le corps de la requête

Quiz. Quelle superglobale contient les champs d'un formulaire envoyé avec la méthode POST ?

• $_GET
• $_POST
• $_SERVER

Références

• php.net : la superglobale $_SERVER
• php.net : json_encode
• MDN : méthodes de requête HTTP