Aller au contenu

PHP

➡️ PHP - Manual

PHP, initialement Personal Home Page (puis redéfini comme PHP: Hypertext Preprocessor), est un langage de script open source principalement utilisé pour le développement web. Créé en 1994 par Rasmus Lerdorf, PHP a commencé comme un ensemble de scripts CGI écrits en C, destinés à gérer le site personnel de son créateur. Au fil du temps, PHP a évolué pour devenir l'un des langages côté serveur les plus utilisés au monde.

Note

Un site web dynamique est un site dont le contenu change en fonction des actions de l'utilisateur, des données reçues ou du contexte. Contrairement aux sites statiques (contenu fixe), les sites dynamiques s'adaptent en temps réel.

Exemples

  • Réseaux sociaux (contenu personnalisé).
  • Boutiques en ligne (catalogues filtrés, paniers).
  • Forums, blogs interactifs.
  • Sites affichant des données mises à jour (statistiques, météo, etc.)

Objectifs et philosophie

  • Faciliter la création de sites dynamiques : PHP est conçu pour "assembler" du HTML en fonction des données.
  • Exécution côté serveur : Le code PHP s'exécute sur le serveur et génère du HTML envoyé au navigateur.
  • Intégration simple : PHP peut être inséré directement dans du HTML, rendant son adoption accessible.

Utilité et fonctionnalités

  • Création de sites web dynamiques et interactifs.
  • Connexion simple à des bases de données (MySQL, PostgreSQL, SQLite, etc.).
  • Gestion des sessions, cookies, formulaires, fichiers, etc.
  • Grande communauté et nombreux frameworks (Laravel, Symfony).
  • Portable : fonctionne sur Windows, Linux, macOS.

Exemples de systèmes basés sur PHP

  • WordPress, qui alimente plus de 40% du web.
  • Magento (e-commerce).
  • Pages et services historiques de Facebook ou Wikipedia.

cms-trend.png

Source image

PHP : langage interprété

Le code est exécuté directement, instruction par instruction, par un interpréteur, lors de chaque requête.

Avantages

  • Aucune compilation : développement rapide.
  • Code modifiable immédiatement après déploiement.
  • Très portable (serveur web Nginx, Apache, IIS, etc.).

Inconvénients

  • Moins performant qu'un langage compilé.
  • Détection d'erreurs uniquement à l'exécution.
  • Risques si le code est mal protégé (injections SQL, XSS…).

compiler-vs-interpreter.png

Source image

Paradigme impératif

PHP suit principalement le paradigme impératif : un programme est une suite d'instructions modifiant un état.

Cependant, depuis PHP 5+, PHP supporte aussi pleinement la programmation orientée objet, mais son coeur reste impératif.

Influences de PHP

Héritage de C

  • Syntaxe générale (accolades, if, for, while).
  • Gestion des fonctions très similaire.

Héritage de Perl

  • Sigils ($variable).
  • Manipulation avancée de chaînes et expressions régulières.

Influences secondaires

  • Concepts orientés objet inspirés de Java / Python.

Popularité

PHP reste aujourd'hui un des langages les plus utilisés côté serveur.

php-trend.png

Source image

Fonctionnement

La communication entre nginx et PHP-FPM (FastCGI Process Manager) constitue la base du fonctionnement d'un serveur web PHP moderne. Lorsqu'une requête arrive, plusieurs étapes s'enchaînent pour produire une réponse dynamique.

  1. Réception de la requête par nginx

    • Un client (navigateur, API, outil CLI…) envoie une requête HTTP.
    • nginx écoute sur un port (80 pour HTTP, 443 pour HTTPS) et reçoit la requête.
    • nginx analyse l'URL :
      • Si la ressource demandée est statique (image, CSS, JS, fichier PDF…), nginx la sert directement.
      • Si la ressource nécessite l'exécution d'un script PHP, nginx transfère la requête à PHP-FPM.

  2. Communication avec PHP-FPM

    • nginx utilise le protocole FastCGI pour communiquer avec PHP-FPM.
    • La communication se fait :
      • soit via un socket Unix (/run/php/php-fpm.sock)
      • soit via un port TCP (ex. 127.0.0.1:9000)
    • PHP-FPM reçoit la requête et délègue son exécution à un worker PHP.
    • Le script PHP est interprété :
      • traitement de formulaires
      • génération de contenu dynamique
      • lecture/écriture de fichiers
      • accès à une base de données
      • etc.

  3. Retour de la réponse à nginx

    • Le script PHP génère du contenu (HTML dans la majorité des cas, mais aussi JSON, XML, etc.).
    • PHP-FPM renvoie ce contenu à nginx via FastCGI.
    • nginx reçoit la réponse et la prépare pour l'envoi au client.

  4. Envoi de la réponse au client

    • nginx renvoie la réponse HTTP complète au navigateur.
    • Le navigateur interprète le contenu et affiche la page.

Ce fonctionnement offre une séparation claire des responsabilités :

  • nginx : serveur web performant, spécialisé dans la gestion du trafic, du caching, et des fichiers statiques.
  • PHP-FPM : moteur d'exécution pour scripts PHP, optimisé pour la performance et la gestion de processus.

nginx-php.png

Source image

Exemple

<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="utf-8">
    <title>Demo</title>
  </head>
  <body>
    <?php
    $text = 'Hello world!';
    echo $text;
    ?>
  </body>
</html>

php-demo-code.png

php-demo-web.png

Syntaxe

Fichier

Les fichiers PHP sont des fichiers texte encodés en UTF-8.

L'extension standard pour les fichiers contenant du code PHP est .php.

Balises PHP

Le code PHP est encadré par les balises ouvrantes <?php et fermantes ?>. Elles indiquent où commence et se termine le code PHP dans un fichier.

Dans un fichier contenant uniquement du PHP, il est recommandé de ne pas mettre la balise ?> à la fin du fichier. Cela évite l'apparition accidentelle d'espaces ou de sauts de lignes après la balise, ce qui pourrait provoquer :

  • des erreurs
  • des warnings
  • des problèmes d'en-têtes HTTP (headers already sent)

Tout contenu situé en dehors des balises PHP est traité comme texte brut, généralement du HTML. Ce contenu est directement envoyé dans la réponse HTTP.

  • Cette capacité permet d'intégrer facilement du code PHP parmi du HTML dans des fichiers mixtes.

Balise courte d'affichage

La syntaxe <?= est une forme raccourcie de :

<?php echo ...; ?>

Elle est utilisée pour afficher rapidement la valeur d'une expression, souvent dans du HTML :

<h1><?= $title; ?></h1>
<h1><?php echo $title; ?></h1>

Les deux instructions produisent exactement le même résultat.

Commentaires

PHP prend en charge plusieurs styles de commentaires, similaires à ceux du langage C/C++.

<?php
// Commentaire sur une seule ligne

/*
 * Commentaire sur plusieurs lignes,
 * utile pour documenter un bloc de code.
 */

Instructions

En PHP, chaque instruction doit se terminer par un point-virgule ;. Ce caractère indique explicitement au parser PHP la fin d'une instruction, permettant d'enchaîner correctement les lignes de code.

<?php
echo 'Hello';
$name = 'Alice';
$count = 3;

Oublier le point-virgule entraîne une erreur de syntaxe.

Variables

Toutes les variables en PHP commencent par le symbole dollar $, suivi du nom de la variable.

L'opérateur = est utilisé pour affecter des valeurs aux variables.

Les noms de variables peuvent inclure des lettres, des chiffres et des underscores (_), mais ne peuvent pas commencer par un chiffre.

Les noms de variables sont sensibles à la casse : $Variable et $variable sont considérées comme deux variables distinctes.

<?php
$name = 'Joe';
$Name = 'Bob';
echo "$name, $Name";    // output: Joe, Bob

$4site = 'not yet';     // invalid: starts with a number
$_4site = 'not yet';    // valid: starts with an underscore

PHP est un langage à typage dynamique. Le type d'une variable est automatiquement déterminé en fonction de la valeur affectée.

PHP supporte plusieurs types de données :

  • Booléens (boolean) : valeurs true ou false.
  • Entiers (integer) : nombres entiers, positifs ou négatifs.
  • Nombres flottants (float) : nombres décimaux.
  • Chaînes de caractères (string) : séquences de caractères.
  • Tableaux (array) : collections de valeurs.
  • Objets (object) : instances de classes.
  • Ressources (resource) : références vers des ressources externes (ex. base de données).
  • null : absence de valeur.
<?php
$a = 3;
$b = 5;
echo $a + $b;  // outputs: 8

$a = 'seven';
echo $a + $b;  // error

php-syntax-example-1.png

Les variables déclarées en dehors de toute fonction ont une portée globale, et ne peuvent pas être accédées directement à l'intérieur des fonctions.

Les variables déclarées dans une fonction ont une portée locale à cette fonction.

<?php
$a = 1;                // global variable
function test()
{
    $a = 2;            // local variable
    echo $a;
}
test();                // output: 2
echo $a;               // output: 1

php-syntax-example-2.png

PHP fournit également plusieurs variables superglobales, accessibles partout (code, fonctions, etc.) :

  • $_GET : données envoyées via l'URL (méthode GET).
  • $_POST : données envoyées dans le corps de la requête (méthode POST).
  • $_SESSION : données persistantes entre plusieurs requêtes d'un même utilisateur.
  • $_COOKIE : données stockées dans les cookies.
  • $_SERVER : informations sur l'environnement serveur et la requête HTTP.
  • Etc.

Chaînes de caractères

En PHP, les guillemets simples (') et les guillemets doubles (") servent à délimiter des chaînes de caractères, mais leur comportement diffère légèrement.

Guillemets simples '

  • Le contenu est traité littéralement.
  • Les variables ne sont pas interprétées.
  • Les séquences d'échappement comme \n ne sont pas interprétées (à l'exception de \\ et \').
  • Légèrement plus rapide car PHP n'analyse pas la chaîne.
<?php
$text = 'World';
echo 'Hello $text';  // output: Hello $text

php-syntax-example-3.png

Guillemets doubles "

  • Les variables sont interprétées dans la chaîne.
  • Les séquences d'échappement comme \n, \t sont prises en compte.
<?php
$text = 'World';
echo "Hello $text";  // output: Hello World

php-syntax-example-4.png

Concaténation

  • L'opérateur . permet de concaténer plusieurs chaînes.
<?php
$text = 'The answer is ';
$number = 42;
echo $text . $number;  // output: The answer is 42

php-syntax-example-3.png

Tip

Pour améliorer la lisibilité, il est souvent préférable d'utiliser des guillemets doubles et l'interpolation plutôt que . lorsque c'est possible.

Echappement

  • Pour inclure des guillemets dans une chaîne, utilisez \ :
<?php
echo 'Escape \' single quote';  // output: Escape ' single quote

php-syntax-example-6.png

<?php
echo "Escape \" double quote";  // output: Escape " double quote

php-syntax-example-7.png

Curly syntax

  • L'utilisation des accolades { } permet de désambiguïser les variables dans une chaîne double-quoted.
  • Utile pour les variables suivies de texte ou pour les expressions plus complexes.
<?php
$text = 'file';
echo "A folder can contain many {$text}s";  // A folder can contain many files

php-syntax-example-8.png

Booléen

Le type boolean en PHP représente une valeur logique pouvant être soit true (vrai), soit false (faux).

PHP étant un langage à typage dynamique, toute valeur peut être automatiquement convertie en booléen lorsqu'elle est évaluée dans un contexte logique (ex. : condition if).

Règles de conversion en booléen

Les valeurs suivantes sont considérées comme false :

  • Le nombre entier 0 ou le flottant 0.0
  • La chaîne vide ''
  • La chaîne '0'
  • Le tableau vide []
  • La valeur spéciale null
  • Certaines autres valeurs spécifiques (hors du cadre de ce cours)

Toutes les autres valeurs sont considérées comme true.

Entier

Le type entier en PHP représente des nombres entiers, positifs ou négatifs, sans partie décimale.

Un entier peut être exprimé dans différentes notations numériques :

  • Décimale (base 10) : Notation standard → 123
  • Hexadécimale (base 16) : Préfixée par 0x → 0x1A
  • Octale (base 8) : Préfixée par 0o → 0o23
  • Binaire (base 2) : Préfixée par 0b → 0b101001

Tableau

Un tableau en PHP est une structure de données flexible permettant de stocker plusieurs valeurs sous un même nom. Les tableaux peuvent être indexés, associatifs, ou multidimensionnels.

Tableaux indexés

Les index sont attribués automatiquement en commençant par 0.

<?php
$array = ['apple', 'orange', 'banana'];

Accès :

<?php
$value = $array[0];  // 'apple'

Tableaux associatifs

Chaque élément possède une clé définie explicitement :

<?php
$array = ['a' => 'apple', 'o' => 'orange', 'c' => 'banana'];

Accès :

<?php
$value = $array['a'];  // 'apple'

Création d'un tableau

Deux syntaxes équivalentes :

  • Avec array() : array('valeur1', 'valeur2');
  • Avec la syntaxe courte [] (préférée aujourd'hui) : ['valeur1', 'valeur2'];
<?php
$array = [1, 2, 3];

Flexibilité extrême (et parfois piégeuse)

PHP autorise presque tout en matière de clés :

<?php
$array = [
    1 => 'one',
    '2' => 2,
    0 => false,
    'value',
    -7 => '-7',
    'key' => 'value',
    null => null,
];
var_dump($array);

php-syntax-example-9.png

Itération

La boucle foreach est la méthode la plus pratique pour parcourir un tableau :

<?php
$array = [2, 40];
$sum = 0;

foreach ($array as $value) {
    $sum += $value;
}

echo $sum; // 42

php-syntax-example-10.png

Tableaux multidimensionnels

Un tableau peut contenir d'autres tableaux. Ils permettent de modéliser des structures plus complexes :

<?php
$library = [
    [
        'titre' => 'Le Grand Gatsby',
        'auteur' => 'F. Scott Fitzgerald',
        'ISBN' => '1234567890',
    ],
    [
        'titre' => '1984',
        'auteur' => 'George Orwell',
        'ISBN' => '0987654321',
    ],
    [
        'titre' => 'Le Seigneur des Anneaux',
        'auteur' => 'J.R.R. Tolkien',
        'ISBN' => '1122334455',
    ],
];

echo '<pre>';
foreach ($library as $count => $book) {
    echo 'Livre ' . ($count + 1) . "\n";
    foreach ($book as $key => $value) {
        echo "- $key : $value\n";
    }
    echo "\n";
}
echo '</pre>';

php-syntax-example-11.png

null

En PHP, null représente l'absence de valeur. Une variable est null si :

  • Aucune valeur ne lui a été assignée
  • Elle a été explicitement définie à null
<?php
$var;
$var = null;

Pour tester si une variable vaut null, on utilise la fonction is_null() :

<?php
$var = null;
echo is_null($var);  // output: 1

php-syntax-example-12.png

Une variable non définie est également considérée comme null, mais :

  • Y accéder génère un warning
  • Il est recommandé d'utiliser isset() avant d'accéder à une variable incertaine
<?php
echo is_null($var);  // output: warning

php-syntax-example-13.png

Structures de contrôle conditionnelles

Les structures conditionnelles permettent d'exécuter du code en fonction d'une condition.

  • if : Exécute un bloc si la condition est vraie.
  • else : S'exécute lorsque la condition du if est fausse.
  • elseif : Permet de tester une autre condition si la précédente est fausse.
  • switch : Permet de comparer une variable à plusieurs valeurs possibles. Chaque valeur correspond à un case.

Boucles

  • while : Exécute un bloc tant que la condition est vraie.
  • do-while : Comme while, mais garantit au moins une exécution avant de tester la condition.
  • for : Boucle avec initialisation, condition d'arrêt et incrément.
  • foreach : Spécifique aux tableaux. Permet de parcourir facilement chaque élément.

Autres structures de contrôle

  • break : Permet de sortir immédiatement d'une boucle ou d'un switch.
  • continue : Ignore le reste du code de l'itération en cours et passe directement à la suivante.

Syntaxe alternative

En PHP, il existe une syntaxe alternative pour les structures de contrôle et les boucles. Elle remplace les accolades { } par des deux-points : pour ouvrir un bloc, et par un mot-clé spécifique (comme endif;, endforeach;, etc.) pour le fermer.

  • Cette syntaxe est particulièrement utile dans les fichiers PHP contenant beaucoup de HTML.
  • Elle améliore la lisibilité en évitant l'enchevêtrement d'accolades dans le code mixte PHP/HTML.

Exemple avec une condition

<body>
  <?php
  $condition = true;
  if ($condition): ?>
    <p>La condition est vraie.</p>
  <?php else: ?>
    <p>La condition est fausse.</p>
  <?php endif; ?>
</body>

Exemple avec une boucle foreach

<body>
  <?php $fruits = ['apple', 'orange', 'banana']; ?>
  <ul>
    <?php foreach ($fruits as $fruit): ?>
      <li><?= $fruit ?></li>
    <?php endforeach; ?>
  </ul>
</body>

Fonction

Les fonctions en PHP permettent de regrouper du code réutilisable. Elles facilitent l'organisation, la lisibilité et la maintenance des programmes.

Une fonction se déclare avec le mot-clé function, suivi de son nom, d'une paire de parenthèses, puis d'un bloc de code entre accolades.

<?php
function function_name()
{
    // Code
}

Une fonction peut recevoir des arguments : des valeurs qui lui sont passées au moment de l'appel.

<?php
function say_hello($name)
{
    echo "Hello $name";
}

Une fonction peut retourner une valeur avec return. Dès que return s'exécute, la fonction s'arrête immédiatement.

<?php
function add($a, $b)
{
    return $a + $b;
}

Pour exécuter une fonction, on écrit simplement son nom suivi de parenthèses (avec les arguments si nécessaire).

<?php
say_hello("Alice");  // output: Hello Alice
echo '<br>';
echo add(5, 7);      // output: 12

php-syntax-example-14.png

Les arguments peuvent avoir des valeurs par défaut. Ces valeurs sont utilisées si aucun argument n'est fourni.

<?php
function say_hello($name = 'anonymous')
{
    echo "Hello $name";
}

PHP supporte également les fonctions anonymes (closures), utiles notamment pour les callbacks.

<?php
$callback = function ($arg) {
    echo $arg;
};

Inclusion de fichiers en PHP

PHP permet de diviser le code en plusieurs fichiers et de les inclure au besoin. C'est indispensable pour structurer correctement une application (templates, configuration, fonctions, etc.).

include et require

  • include '/path/to/file.php'; : Si le fichier n'existe pas → warning, mais le script continue.
  • require '/path/to/file.php'; : Si le fichier n'existe pas → erreur fatale, le script s'arrête immédiatement.

include_once et require_once

  • Empêchent qu'un même fichier soit inclus plusieurs fois.
  • Evitent des erreurs telles que la redéfinition de fonctions ou de classes.

rtfm.png

Source image