Topic outline

  • General

    Collapse all Expand all

    Informations, documentation technique, cours et tuto :


    Connaissances requises :

    PHP étant un langage de programmation orienté web, il vous faudra maîtriser un minimum ces différentes compétences avant de vous lancer :

    • HTML / CSS : même si on pourrait se passer entièrement de HTML / CSS pour faire du PHP, les deux sont liés la plupart du temps
    • bases théoriques en programmation : à savoir l'algorithmie et un minimum de culture technique (conditions, boucles, etc...)
    • comprendre l'architecture client / serveur
    • comprendre l'utilisation et l'utilité des bases de données


    Avant de commencer : installer un logiciel en local type EasyPHP ou Wamp, afin de pouvoir exécuter du PHP sur votre ordinateur.


  • Présentation

    Contrairement à HTML et CSS qui sont des langages de balisage et de style, PHP est un langage de programmation. La différence est énorme, car en PHP vous allez pouvoir faire des choses impossible à faire à l'aide du HTML ou CSS. Un langage de programmation vous permet de commander à un ordinateur de :

    • faire des calculs (les ordinateurs dépassent largement l'humain dans cette tâche)
    • exécuter des instructions
    • écrire des algorithmes
    • et bien plus encore...!

    De la même manière qu'il y a plusieurs langages selon les différents peuples sur Terre, il y a aussi de nombreux langages qui existent en programmation logiciel. Ils ont tous une histoire et une raison d'être différentes. Par exemple les langages bas niveau permettent de programmer des éléments électroniques (puces, périphériques, etc... ex : le langage C). Ce sont les premiers langages à avoir vu le jour, car il fallait bien programmer les éléments de base des tous premiers ordinateurs (processeurs, mémoire, affichage, etc...). Dans ce cas, les problématiques sont proches du hardware, et de l'électronique. Voici un wiki complet sur l'histoire des langages informatique.

    PHP est le langage de programmation historiquement adapté aux problématiques du web. Ça n'est pas le seul, mais il règne en maître sur le cercle assez restreint des langages back-end utilisés dans les technos web. Découvrons-le !



    Naissance du langage

    PHP a été créé en 1994 par un informaticien prénommé Rasmus Lerdorf. Ce dernier avait créer une petite page web pour présenter son CV, et il voulait savoir combien de visiteurs avait atterri sur sa page. Les technos web étant encore balbutiantes à l'époque, il décida de créer une série d'outils, écrit en C, afin de pouvoir compter ses visiteurs. Au début, PHP (pour Personal Home Page) n'était donc qu'un ensemble d'outils installés sur le serveur web qui permettaient de faire des choses très simples, mais encore très peu répandues à l'époque. Rasmus publia son code en 1995 et cette première version évolua tranquillement. Une communauté commença à l'adopter et à l'implémenter dans différents projets web.


    Principaux créateurs de PHP

    Ramsus Lerdorf
    Andi Gutmans
    Zeev Suraski



    En 1997, deux étudiants israéliens - Andi Gutmans et Zeev Suraski - ont complètement réécris le cœur de PHP pour leurs propres besoins, ce qui donna naissance au Zend Engine (moteur d'exécution des scripts PHP), et qui sera la base des futurs version de PHP, jusqu'à aujourd'hui.

    Donc pour que les choses soient claires : PHP a été créé par un gars qui cherchait du boulot et qui avait assez de temps libre pour créer son petit langage "maison" :) Aujourd'hui, c'est a minima 80% des sites web, c'est ce qu'on appel un bon karma.


    Généralités

    PHP est un langage open-source, maintenu par une équipe de développeurs, rattachés à la société Zend Technologies. C'est un langage de script, cela veux dire que le développeur n'a pas à compiler son code en langage machine avant de l'exécuter. D'autres langages nécessitent absolument cette étape afin de pouvoir exécuter un programme. En PHP, c'est un interpréteur qui va "lire" vos instructions, et qui va les compiler en langage machine "à la volée".

    Voici un schéma qui représente ce mode de fonctionnement :



    Evolution

    De part sa popularité, PHP a constamment évolué depuis sa création. Les équipes de développeurs qui s’attellent à améliorer et corriger le langages. La dernière version stable est la 7.3 (8 décembre 2018). Depuis sa création, de nombreuses fonctionnalités y ont été rajouté, telles que par exemple :

    • la gestion des variables "super globales"
    • l'exécution en ligne de commande
    • l'ajout de bibliothèque et de modules (PDO, images, etc...)
    • meilleure structuration de l'aspect POO
    • amélioration des performances et du système de compilation "à la volée"
    • possibilité de typage fort
    • etc...

    Une version 8 est prévue pour 2020/2021.

    La version 7 a été un gros gap pour les usagers de PHP, car il y a eu un temps très long entre la 5.6 et la 7.0. La 6 n'étant jamais sortie pour cause de rétropédalage sur des choix techniques. Il y a donc encore beaucoup de projets qui tournent sur une version "ancienne" de PHP (5.4 ou 5.6). Mais la politique de Zend Technologies mais l’accent sur la rétro-compatibilité entre les différentes versions de PHP, et on peu donc facilement migrer d'une version majeures vers une autre. Cette politique a pour conséquence de laisser "traîner" des vieilles fonctions dans des nouvelles versions, ce qui peux en faire bondir certains. En revanche, si on utilise certains framework ou certaines fonctions, il se peut que l'on soit contraint d'utiliser une version récente de PHP pour avoir accès aux dernières fonctionnalités offertes par le langage.


    Utilisation

    Même si une certaines parties des développeurs déconsidèrent PHP, il n'en reste pas moins un langage ultra répandu dans l'éco-système du web. Avec 8 millions de sites web qui tournaient grâce à PHP en 2002, PHP est présent sur plus de 80% des sites web 2018. Ce qui prouve qu'il fait le job correctement, malgré ses détracteurs.

    Part de marché de PHP sur les serveurs web en 2018 :



    Cette hégémonie est, selon moi, dû à un éco-système très riche et florissant d'outils ultra répandus qui se basent sur la langage PHP pour répondre aux besoins des usages d'Internet. Même si de nombreux développeurs travaillent sur des projets PHP "from-scratch", de nombreux outils déployés à travers le monde utilisent PHP pour mettre à disposition de leurs utilisateurs des solutions fiables, complètes et performantes.

    Voici un exemple de technologies codées en PHP :



    On constate grâce à ce schéma, que PHP est vraiment positionné sur des usages extrêmement répandus dans le monde du web (CMS, e-commerce, forum,  ERP & CRM, compatibilité avec les bases de données, etc...). Moodle, que vous utilisez en ce moment même, est écrit en PHP. Hourra !

    Et voici une liste non-exhaustives de grandes compagnies réputées qui ont fait le choix de PHP pour développer leurs plateforme :

    • Facebook
    • Wikipedia
    • MailChimp
    • Tumblr
    • Slack
    • DailyMotion
    • Etsy

  • PHP et serveur

    Contrairement à de nombreux langages de programmation, PHP est taillé pour le web, son domaine originel. Il incorpore donc depuis le début beaucoup de fonctionnalités propres aux problématiques du web telles que :

    • une bonne intégration à l'environnement web (serveurs web, protocole HTTP,...)
    • la possibilité de "mélanger" facilement le PHP et le HTML (templating)
    • la possibilité de fonctionner facilement avec une base de données
    • des fonctionnalités propres au web (envoi de mail, XML/JSON, etc...)
    • et de nombreuses autres...


    Architecture

    PHP est un langage back-end. Cela veux dire qu'il s’exécute la partie serveur de l'architecture client/serveur. On aura donc des problématiques back-end à gérer :

    • exploiter une base de données
    • traiter des données envoyées par l'internaute (le client)
    • écrire la logique métier prise en charge par le serveur
    • etc...


    Très souvent intégré à une stack XAMP (OS + Apache/Nginx + MySQL/MariaDB + PHP)(on parle souvent d'une stack LAMP), PHP s'installe et se configure assez facilement avant de pouvoir l'utiliser. De nombreux packages ou logiciels vous permettent de mettre en place un environnement PHP en quelques clics, ou quelques lignes de commandes :

    • EasyPHP ou Wamp pour Windows
    • installation aisée sous Linux (voir un exemple sur cette page si ça vous intéresse : https://doc.ubuntu-fr.org/lamp)
    • Mamp pour Mac


    Protocole HTTP

    Avant tout, voir le cours sur le protocole HTTP.

    PHP étant un langage web, il y a une très forte connexion avec le protocole HTTP. En plus des fonctionnalités de bases liées au protocole HTTP (ex : renvoyer une simple page HTML), on va pouvoir agir sur différents aspects de ce protocoles grâce à PHP :

    • réagir différemment selon les méthodes utilisées dans les requêtes (GET, POST, PUT,...)
    • récupérer des données provenant de l'utilisateur (informations, fichiers, méta-données,...)
    • configurer des éléments d'entêtes HTTP (gestion du cache, MIME-type des réponses, cross-origin,...)
    • etc...

    Même si HTTP est un protocole sur lequel nous n'avons pas vraiment la main en PHP, il faut bien comprendre son fonctionnement pour pouvoir en exploiter toutes les facettes.


    Configuration

    De nombreux paramètres propres à PHP sont configurables via un fichier : php.ini. Il se trouve généralement dans le dossier PHP de votre serveur, mais il peux être redéfini localement pour chaque projets ou dossiers. Le serveur web prendra en compte le dernier fichier php.ini qu'il croisera sur "sa route" avant l'exécution du script. Le fichier php.ini contient de nombreuses directives concernant le comportement que doit avoir PHP. Voici quelques exemples :

    • gestion des erreurs : afficher tout, afficher que les plus graves, ne rien afficher
    • déterminer la taille maximale d'un fichier uploadé
    • temps d'attente maximum avant de renvoyer une erreur
    • etc...

    Il y a de très nombreuses directives possibles, en voici la liste : https://www.php.net/manual/fr/ini.list.php. Toutes les directives possibles ne sont pas forcément exactement à jour sur la doc, donc le mieux est de voir directement dans votre fichier php.ini celle qui sont présentes dans votre version de PHP.

    Voici à quoi ressemble un fichier php.ini :



    Important : certaines directives peuvent être modifiées directement dans le code en utilisant la fonction ini_set().


    Fonctionnalités natives

    PHP propose nativement de nombreuses variables ou fonctions qui sont utilisées pour la communication avec le serveur web ou le système d'exploitation, telles que :

    • $_REQUEST, $_GET, $_POST, $_FILES pour récupérer des données envoyées par l'utilisateur
    • $_SERVER pour accéder à certains paramètres du serveur web (adresse IP, nom de domaine, script courant,...)
    • $_SESSION qui permet de stocker des informations sur l'utilisateurs le temps d'une session (sous forme de fichier ou dans une base de données)
    • parcourir et modifier le système de fichier
    • exécuter des commandes système
    • prise en compte de l'internationalisation via les locales systèmes 
    • etc etc...

    Modules

    Il ne faut pas oublier que l'on peut installer des modules supplémentaires à PHP pour effectuer des tâches précises, mais pas assez génériques pour les inclure nativement dans PHP. 

    Voici quelques exemples :

    • php-json : traitement du json
    • php-gd : traitement des images
    • php-curl : récupérer le contenu d'une url distante
    • etc...


    Vous devrez vérifier la présence de ces modules selon les besoins de votre application. Bien souvent chez les hébergeurs, certains modules sont disponibles, mais pas forcément. A vous de voir si vous pouvez faire avec, ou si vous avez suffisamment de droits pour en installer des nouveaux.



    Hébergement
    Il y a en général 3 types d'installations possibles pour un projet PHP :

    1. en local (ce qui veux dire sur votre propre machine). Ce type d'installation est normalement faites pour la phase de développement de votre projet. Vous n'avez qu'a installer la stack souhaitée sur votre machine, faire un peu de configuration, et c'est parti. Une fois que vous aurez développé ce que vous souhaitez, il faudra envoyer vos scripts sur un serveur dit de production.
    2. sur un serveur mutualisé. Adapté pour des petits projets simples (sites web, appli a faible trafic, etc...), ce type d'hébergement vous propose à moindre frais un environnement pré-configuré, ou vous pourrez lancer votre projet rapidement, et avec peu de travail d'administration (db pré-installée, réglages "par défaut", systèmes sécurisées, etc...). En revanche votre application tournera sur un serveur physique partagé par de nombreux clients, donc on aura une nette perte de performance par rapport à un serveur dédié.
    3. sur un serveur dédié. Dans ce cas, vous disposez de votre propre machine dans un data-center, avec une bande passante maximale, et un accès aux ressources hardware 100% dédié à votre projet. Le coût est plus élevé, des compétences techniques pour la mise en place et la maintenance sont nécessaires, et vous devez disposer d'un minimum de connaissances en administration système.


    Donc pour conclure, on peux dire que PHP "out of the box", offre des fonctionnalités utiles au développement d'une application web. D'autres langages proposent aussi ce genre de choses, mais il faut bien souvent passer par l'installation de librairies dédiées à une tâche précise. Ce qui peut s'avérer fastidieux dans certains cas (grand nombre de librairies disponibles, mises à jours régulières, maintenabilité et évolution des librairies, granularité excessive, etc...).

  • PHP et HTML

    Une des fonctions originel de PHP, c'est de générer des pages HTML de manière dynamique. Cela veux dire que l'on va pouvoir afficher en HTML des résultats différents selon certains paramètres. Ce qui est impossible à faire avec le seul usage de HTML. Donc, en restant toujours dans une approche très généraliste, on peux conceptualiser les entrées / sorties de PHP de cette manière :

    1. entrées : paramètres (quel page ? que données envoyées ? quels réglages serveur ? ... ). Les entrées sont, en général, déterminées par le contenu de la requête HTTP reçu par le serveur web
    2. sortie : un document HTML, ayant un contenu différent en fonction des entrées reçues


    Cette approche est très simpliste, mais l'idée de base du PHP est là. Et si on se re-contextualise en 1994, lors de la création de PHP, et avant l'explosion du web, on peux dire que c'est une idée qui a du potentiel. 

    Voici un schéma résumant cette approche :




    On peux faire beaucoup d'autres choses que générer du HTML en PHP :

    • tâches de maintenance, sans affichage (ex : tâches cron, nettoyage de DB, réponse AJAX en texte brut,...)
    • POO dédiée à la logique métier (via un design pattern MVC leur par exemple)
    • génération de document de différentes natures (PDF, XML, JSON,...)
    • utilisation de protocole différents (SMTP pour l'envoi de mail par exemple)
    • script particuliers, comme de la manipulation d'image (redimensionnement, compression, crop,...)


    PHP permet de faire du templating HTML facilement. C'est une de ses principales fonctionnalités, nous aborderons le sujet un peu plus tard dans ce cour.

  • Syntaxe

    Les balises PHP

    Afin que le code PHP soit interprété par le moteur PHP (et pas afficher comme une sortie HTML standard), il faut qu'il soit placé entre des balises PHP, de cette forme :

    <?php
...code PHP...
?>

    Tout ce qui sera en dehors de ces balises sera affiché comme du HTML standard. Il y a différentes formes de balises PHP, en plus de celle que nous venons de voir. Si vous avez un éditeur digne de ce nom, vous ne pourrez pas oublié ça, grâce à la coloration syntaxique qui ne sera pas la même pour du PHP et du HTML.


    Ecriture raccourcie, mais dépend de la configuration du serveur

    Nécessite l'activation de la directive short_open_tags dans le php.ini. 

    <?   //pas de caractères 'php' après le chevron
...code...
?>

    Personnellement, je trouve ça beaucoup mieux. L'ouverture de balise peut être très fréquente en PHP, et donc se délester d'écrire "php" à chaque fois me semble plutôt bien. Le problème c'est la portabilité. Si vous migrez votre code sur une nouvelle machine, qui n'est pas correctement configurée pour accepté les short tags, votre script ne marchera pas. A vous de voir.


    Ecriture qui sous entend un affichage direct

    Prenons un exemple, avec l’affichage du prénom :

    <?
echo $prenom; //On souhaite afficher le prénom
?>

    Cette instruction pourra s'écrire avec cette forme : 

    <?=$prenom?> <!--Résultat identique. Le <?= (signe égal) remplace le echo.-->

    Bien pratique pour avoir des templates propre et plus lisibles. Vous pouvez en abuser, c'est une syntaxe native de PHP.


    Balise de fermeture

    Si une page contient uniquement du code PHP, sans affichage, alors vous pouvez ne pas mettre de balise de fermeture ?>. Cela afin d'éviter tout espace ou retour à la ligne "oubliés", ce qui engendrerai un début d'affichage non désiré, et potentiellement générateur de bugs (notamment par la préparation d’entêtes HTTP pour une réponse qui ne partira jamais).


    Instructions et points-virgules

    Les points virgules représentent la fin d'une instruction dans de nombreux langages de programmation. Ils sont obligatoires en PHP. 

    Exemple :

    echo 'Hello world';  /*Le point virgule représente la fin d'une instruction*/

    Si vous omettez un point virgule, votre script plantera et vous renverra un message d'erreur plus ou moins explicite. Je vous informe que vous vous casserez les dents à coup sur avec ce genre d'oublis pas très glorieux au début de votre apprentissage de PHP.


    Blocs d'instructions

    Comme dans de nombreux langages, on va utiliser les accollades pour représenter un bloc d'instruction lié à une condition, une boucle, ou tout autre structure. Ces "blocs" servent à regrouper une série d'instructions. 

    Exemple :

    <?php
    if ($age < 18) {
        echo "Vous êtes mineur";
        /*autres instructions*/
    } else {
        echo "Vous êtes majeur";
        /*autres instructions*/
    }
    ?>

    Dans ce cas, les "echo" ne seront exécutés que si les conditions sont "vraies" (true).


    Les commentaires

    En PHP, les commentaires s'écrivent de deux manières. Soit vous ne souhaitez commenter qu'une seule ligne, et vous pouvez utiliser //. 

    Exemple :

    //echo 'Hello world';   Cette ligne ne sera pas exécutée dans votre script

    Ou bien si vous souhaitez commenter un bloc de plusieurs lignes, vous pouvez utiliser /* ....... */. 

    Exemple :

    /*
echo 'Hello world';
echo 'Bonjour le monde';
Tout ce bloc ne sera pas exécuté
*/

    Prise en compte de la casse

    PHP est sensible à la casse. Cela veux dire qu'un caractère en minuscule est interprété différemment que le même caractère en majuscule.

    Exemple :

    $prenom = 'julien a';
$Prenom = 'julien b';
echo $prenom; /* Affichera "julien a" */
echo $Prenom; /* Affichera "julien b" */
echo $PRENOM; /* Affichera une erreur car cette variable n'existe pas */

    Donc faites bien attention aux nommage des différents éléments composant votre code.


    Style d'écriture

    On essaiera au maximum d'utiliser le camelCase (première lettre du mot en majuscule, sauf pour le premier mot) pour toutes les variables et fonctions :

    function affichePersonnage($nomFamille, $prenomPrincipal, $prenomSecondaire){
    echo "$prenomPrincipal ($prenomSecondaire) $nomFamille";
}

    Vous pouvez aussi utiliser les underscore "_" comme séparateur de mots. En revanche le tiret "-" est réservé aux soustractions, donc impossible à utiliser pour le nommage de vos éléments.


    Caractères valides

    Quand on code un logiciel, on essaye d'appliquer ce qu'on appel des "bonnes pratiques". Et on essaye de ne pas faire n'importe quoi. Sauf que dans certains cas, les langages vous autorisent à faire n'importe quoi, ce qui est souvent le cas de PHP. Voici un exemple de chose à ne pas faire :

    $passé = 'past';
$présent = 'present';
$futurç = 'future';
echo $passé; /*Affiche "past"*/
echo $présent; /* Affiche "present" */
echo $futurç; /* Affiche "future"*/

    On évitera au maximum tout ce qui est caractères spéciaux. Si vous codez un truc comme ça, et qu'un développeur anglophone ou germanophone reprend votre code, il ne saura même pas quelle touche de son clavier utiliser pour reproduire les accents et la cédille (ils n'existent tout simplement pas en anglais par exemple). Cela peut devenir très vite frustrant de galérer sur ce genre de détails, donc on respecte la profession en utilisant des standards reconnus par tout le monde. Certains langages vous interdirons clairement cette syntaxe. Voici une page intéressante sur le sujet.

  • Variables, constantes, et types

    Important : Avant de commencer les variables en PHP, voir le cours générique sur :

    1. les algorithmes
    2. les variables et constantes 
    3. les types.


    Utilisation des variables en PHP

    Faire spécificité et exemples de PHP ici.


    Déclarer une variable, le signe $ :

    $prenom = 'julien';

    Déclarer une constante, la fonction define() ;

    define("ANNEE_NAISSANCE", 1985);


    Vrac

    • portée des variables, mot clé global et $GLOBALS
    • ...

  • Opérateurs et expressions

    Voir le cours générique sur les opérateurs.


    La concaténation en PHP

    Une des particularités de PHP concernant la concaténation, c'est la différence entre le guillemet simple et double :

    • les guillemets simples ne devront contenir que des chaînes de caractères
    • les guillemets doubles vont pouvoir interpréter des variables dans une chaîne, ce qui évite de devoir "ouvrir" et "fermer" la chaîne de caractère lorsque l'on veux y concaténer des variables à l'intérieur.

    Exemple :

    $prenom = 'julien';
echo "Bonjour ".$prenom." !";  //point pour concaténer. Affichera : Bonjour julien !

    Peut s'écrire :

    $prenom = 'julien';
echo "Bonjour $prenom !";  //Disparition des points. Affichera : Bonjour julien !

    On peut aussi écrire cela par exemple :

    $prenom = ['julien', 'marc', 'quentin', 'charlotte', 'sarah'];
echo "Bonjour $prenom[2] !";  //Affichera Bonjour Quentin !


    Ce cas de figure ne marche toutefois pas à tous les coup. Si vous souhaitez glisser une instruction dans une concaténation (ce qui peux arriver), il vous faudra certainement utiliser les points, voir les parenthèses.

    Voici un exemple sur un simple compteur qui additionne des chiffres :

    $i = 0;
while ($i < 5){
    echo "$i + 1 = ".($i + 1); //Ici on est obligé d'utiliser le point, et les paranthèses
    $i++;
}

    Vous trouverez aussi des fonctions natives de PHP spécialisées dans la concaténation, tel que implode(). Cette fonction permet de rassembler les éléments d'un tableau dans une chaîne de caractère.

    Exemple :

        $prenom = ['julien', 'marc', 'quentin', 'charlotte', 'sarah'];
    $liste = implode(', ', $prenom);
    echo $liste; //Affichera : julien, marc, quentin, charlotte, sarah


    Trouver spécificités PHP ?

  • Structures conditionnelles

    Voir cours générique sur les structures conditionnelles.


    Petite nuance en PHP, on peux écrire elseif en plus de else if (espace en moins).


    Parler du ":" utiliser dans les template.



    A faire :

    Trouver autres spécificités en PHP ?

  • Structure itératives

    Voir cours générique sur les structures itératives.


    Les boucles en PHP


    Le foreach

    Littéralement "pour chaque...", le foreach permet de parcourir et d'accéder aux valeur d'un "itérable" (tableaux, objets, enum,...) de manière encore plus pratique. Plus besoin de gérer les index, le foreach le fait pour vous. Il suffit juste de spécifier quel élément vous souhaitez parcourir, et de "nommer" les différentes clés/valeurs que vous allez parcourir.


    Exemple avec clé/valeur :

    $couleurs = [
  'red' => 'rouge',
  'blue' => 'bleu',
  'yellow' => 'jaune',
  'green' => 'vert',
  'purple' => 'violet'
];
foreach($couleurs as $anglais => $francais) {  //Ici, j'ai décidé que chaque clé/valeur seront accessibles via $anglais et $francais à chaque tour de boucle
  echo "La couleur '$anglais' se dit '$francais'";
}

    Une autre syntaxe est possible avec les foreach, encore plus simple. Mais elle vous permettra seulement d'accéder aux différentes valeurs du tableau.


    Exemple avec seulement la valeur :

    foreach($couleurs as $couleur) {
    echo "Nous avons la couleur '$couleur' dans notre tableau";
}


    => Copiez ces deux exemples dans votre sandbox. Vérifiez que cela fonctionne bien, puis ajouter des couleurs au tableau $couleurs.


    Ce genre de syntaxes sont très pratiques car elles enlèvent du travail aux développeurs, et leur permettent de se concentrer sur des choses plus importantes (pas de besoin de déclarer de variable $i de compteur par exemple). En revanche, vous ne pourrez utiliser ce type de syntaxe que sur des tableaux, ou objets itérables (donc indexés, tel que les chaînes de caractères). La syntaxe est aussi beaucoup plus digeste à lire, et donc la vérification du code est plus facile, et l'erreur humaine moins grande.


    En PHP, vous pouvez aussi parcourir des objets grâce au foreach, de la même manière que des tableaux.

    Exemple sur un objet :

    $obj = new stdClass();
$obj->nom = "Julien";
$obj->surnom = "Juju";
$obj->age = 33;
$obj->adresse = "1 place du Capitole 31000 Toulouse";
$obj->metier = "formateur en développement web";
foreach($obj as $propriete => $valeur){
    echo "$propriete = $valeur";
}

  • Les fonctions

    Avant de parler des fonctions en PHP, voir le cours générique sur les fonctions.

    Syntaxe PHP

    Voici la syntaxe de base d'une fonction :

        function somme($a, $b){
    return $a + $b;
}

    Donc on retrouve bien notre déclaration (function), notre nom de fonction (somme), nos paramètres ($a et $b, séparés par une virgule),  et notre bloc d'instruction avec le mot clé return. Dans ce cas la, la fonction va retourner la somme de $a + $b. 

    Retour de la fonction : le mot clé return se comporte comme un break, c'est à dire que quand il est exécuté, on "sort" de la fonction, même si il reste du code en dessous. 

    Appel d'une fonction : pour appeler une fonction, on écrit simplement son nom, suivi des parenthèses et des paramètres si il y'en a.

    Portée : les paramètres sont accessibles seulement à l'intérieur de la fonction. On dit qu'ils ont un scope limité à la fonction. Cette notion est très importante, voir le cours générique sur le scope.


    Voici un exemple d'utilisation :

    $premier_nombre = 4;
$deuxieme_nombre = 7;
$resultat = somme($premier_nombre, $deuxieme_nombre);
echo $resultat;

function somme($a, $b){
  return $a + $b;
}

    => Copiez ça dans votre sandbox, et testez différentes valeurs. Faites moi la soustraction, la multiplication et la division, dans la même logique avec de nouvelles fonctions. N'hésitez pas à mettre de grands nombres, ou des nombres à virgule. Testez aussi la notion de scope en renommant vos variables et vos paramètres, et en essayant de les appeler les uns après les autres depuis l'extérieur et l'intérieur de la fonction.

    Petit exercice simple : faites moi une fonction isNegative(), qui vous dira si un nombre est négatif. Ne faites pas de vérification de type, on admet que x est bien un nombre. La fonction retourne soit true, soit false.


    Les paramètres dans les fonctions PHP

    Comme nous l'avons vu dans le cours générique sur les fonctions, on peux paramétrer une fonction PHP de différentes manières :

    • sans paramètres
    • avec un ou plusieurs paramètres
    • avec des paramètres qui ont une valeur par défaut


    Typage des paramètres

    PHP7 a introduit une nouveauté dans la notion de paramètres. On peux désormais "typer" un paramètre. Cela veux dire que la fonction va vérifier que le paramètre reçu suite à un appel de fonction correspond bien au type de données qu'elle attends. Reprenons l'exemple de la fonction somme(). Nous sommes bien d'accord qu'une somme ne peut être faite que sur des variables de type "nombres". Pour l'exemple, nous nous limiterons aux nombres entiers. 

    Voici comment nous pourrions écrire ça en PHP :

    function somme(int $a, int $b){ //Ici, on détermine le type attendu des paramètres
    return $a + $b;
}
echo somme('a',3);   //Affichera une erreur, car 'a' n'est pas un entier
echo somme(3,3);    //Affichera 6

    Voici les types que vous pouvez vérifier dans vos paramètres :

    • string
    • entiers
    • décimaux
    • booléen


    Ce mécanisme est très utile car il permet de détecter un bug avant qu'il ne se produise. En clair, si on n'essaye de faire la somme de 'a' et de 3, la fonction ne s'exécutera pas et affichera une erreur claire, au lieu d'essayer de se débrouiller, et de finir par buger. Cela apporte aussi plus de structure et de rigidité au code.


    Paramètres optionnels

    PHP7 a aussi rajouter le fait qu'un paramètre puisse être défini comme "optionnel". Cela se détermine en utilisant l'opérateur "?" avant le type du paramètre.

    function somme(int $a, int $b, ?int $c){ //$c doit être un entier, mais si il est "null", ça passe quand même
  return $a + $b + $c;
}
echo somme(3, 4, 5);  //Ok, tout est dans l'ordre. Affiche 12
echo '<br />';
echo somme(3, 4, null); //Ok, alors que l'on es sensé envoyé un entier en troisième paramètre. Affiche 7

    Si on enlève le point d'interrogation avant le type du paramètre $c, ce script renverra une erreur car "null" n'est pas un entier.


    Déclaration du type de retour

    On peut aussi déterminer le type de valeur que doit retourner une fonction. avec l'opérateur ":" (deux points), suivi du type scalaire, écrit à la suite de la fonction. On va pouvoir forcer l'interpréteur PHP à vérifier qu'une fonction retourne bien le type attendu. Cela permet d'éviter que des erreurs - humaines ou non - se glissent dans le code.


    function somme(int $a, int $b, ?int $c): int{ //on attends que notre fonction somme nous retourne un entier. Logique.
    $somme = $a + $b + $c;
    return "La somme de $a + $b + $c vaut $somme"; //Ceci est une chaîne de caractère
}
echo somme(3, 4, 5);  //Cette instruction affichera une erreur, bien que le code soit correct.


    Dans cet exemple, un peu capillotracté (personne ne codera jamais ça), on détermine à l'avance que la fonction somme doit retourner obligatoirement un entier. Et ça n'est pas le cas ici, car on retourne la chaîne de caractères "La somme de 3 + 4 + 5 vaut 12". Donc PHP va émettre une erreur, avant que tout ça ne se transforme en bug incompréhensible...



    A RAJOUTER

    Php7 (encore d'autre trucs ?), opérateur spread (cours générique),



    La notion de scope

    Voir cours sur la notion de scope en programmation.

  • Fonctions internes

    Faire des exemples par grande familles :

    • affichage (ne pas oublier les var_dump et compagnie)
    • date
    • string
    • array
    • phpinfo()
    • Json
    • etc...


    Doc officielle : https://www.php.net/manual/fr/functions.internal.php

  • Templating

    Les templates, qui se traduirai par "gabarits" en français, c'est le fait de mélanger un langage de programmation avec un langage de balisage (ou de structuration). Ici, on parle bien de mélanger du PHP avec du HTML. C'est un travail quasi-obligatoire quand on fait une application en PHP qui fournie des documents HTML. 

    Voici un exemple de template HTML/PHP simple :

    $prenom = 'Jean';   //Récupération des valeurs dans les variables
$nom = 'Durand';
$age = 42;
$metier = "Développeur";
<body>
<h1>Fiche de <?php echo $prenom?> <?php echo $nom?></h1>  //Intégration des variable dans la page web
<br />
<u>Age :</u> <?php echo $age?> ans
<br />
<u>Métier :</u> <?php echo $metier?>
</body>

    Et voici le résultat obtenu dans le navigateur web :


    Simple non ?


    Voici un autre exemple de template utilisant les boucles afin de générer une liste HTML. Admettons que l'on travaille sur une liste de personnages $noms, classés dans un certain ordre.


    Etape 1 : template PHP / HTML

    <ul>
    <?php foreach($noms as $rang => $nom) { ?>  //Intégration de PHP dans le code HTML
      <li>Personnage n° <?=$rang?> : <?=$nom?></li>  //Affichage des variables
    <?php } ?>
    </ul>

    Etape 2 : génération du document HTML selon le contenu de $noms

    <ul>
  <li>Personnage n°0 : Julien</li>
  <li>Personnage n°1 : Pierre</li>
  <li>Personnage n°2 : Mathieu</li>
  <li>Personnage n°3 : Elsa</li>
  <li>Personnage n°4 : Laura</li>
  <li>Personnage n°5 : Dimitri</li>
  <li>Personnage n°6 : Kévin</li>
</ul>

    Etape 3 : interprétation par le navigateur, et son moteur de rendu graphique :

    • Personnage n°0 : Julien
    • Personnage n°1 : Pierre
    • Personnage n°2 : Mathieu
    • Personnage n°3 : Elsa
    • Personnage n°4 : Laura
    • Personnage n°5 : Dimitri
    • Personnage n°6 : Kévin


    Ce concept est très important, car en plus de rendre vos pages dynamiques, il vous permet gagner beaucoup de temps par rapport à de l'écriture HTML "statique". Ça n'est plus au développeur d'écrire la totalité du code HTML vu que les données proviennent d'une base de données ou de fichiers. On traitera ces données via un langage de programmation dans le but de générer automatiquement du HTML. Du coup si les données changent, le document HTML change, plus besoin de modifier le code de son site web à la main !

  • Inclusion de fichiers

    En PHP, il est possible d'insérer le contenu d'un fichier dans votre code. Et cela est très pratique, car ça va vous permettre de découper vos scripts dans de nombreux fichiers différents qui vont chacun remplir un rôle précis. Les fichiers appelés peuvent être de toutes sorte (PHP, HTML, CSS, JS, etc...), mais bien souvent, on se cantonnera aux seuls PHP et HTML. 

    Quand vous "appelez" un fichier dans un autre, le contenu du fichier appelé va être "inséré" dans votre fichier appelant, comme si vous aviez copié/collé le contenu de l'un dans l'autre. C'est une pratique extrêmement répandue en PHP, que ce soit en front pour des problématiques de templating et de redondance du code, ou en back pour appeler des fichiers qui contiennent un script particulier. Nous verrons différents cas de figures plus bas.

    Voici un exemple :


    Dans l'exemple ci-dessus, les fichiers "header.php" et "footer.php" ne sont écrit qu'une seule fois. Par contre ils sont appelés dans toutes les pages ou leur présence est requise. Je vous laisse imaginer le gain de temps et d'efficacité.

    Un fichier PHP inclut dans un autre fichier sera exécuté normalement, donc on pourra très bien écrire du code PHP dans les deux fichiers séparément. En revanche il faut faire attention à ne pas rendre les fichiers trop dépendant les uns des autres au niveau du code, car si on change une petite chose quelque part, ça peut vite tout faire bugger.

    Il y a deux approches, assez similaires, pour insérer des fichiers dans votre code.


    Les include

    Les "include", comme leur nom l'indique, vont vous permettre d'inclure un fichier directement à l'intérieur de votre script. La particularité d'un include, c'est qu'il va essayer de charger le fichier en question, mais s’il y a un problème, le script continue son exécution normale. Si vous utilisez include, vous pouvez inclure le même fichier à de multiples reprises dans la même page. En revanche, avec include_once un mécanisme va vérifier si le fichier en question a déjà été inclue, et si c'est le cas, vous ne pourrez pas l'inclure à nouveau (d'où le "once", une fois).

    Voici les deux fonctions natives qui permettent de faire cela :

    • include
    • include_once


    include('fiche-produit.php');  /* Peut être appelé plusieurs fois, ne génère pas d'erreur si le fichier n'existe pas */
include('fiche-produit.php');
include('fiche-produit.php');
include_once('footer.php'); . /* Peut être appelé qu'une seule fois (les autres appels seront ignorés) */


    Les require

    Les "require" vont faire exactement la même chose que les include, sauf qu'ils vont générer une erreur s’il y a un problème au chargement du fichier appelé (fichier inexistant par exemple). Le fichier est donc requis, ça n'est pas optionnel. 


    Voici les deux fonctions natives qui permettent de faire cela :

    • require
    • require_once


    require('fiche-produit.php');  /* Peut être appelé plusieurs fois, génère une erreur si le fichier n'existe pas */
require('fiche-produit.php');
require('fiche-produit.php');
require_once('footer.php'); . /* Peut être appelé qu'une seule fois (les autres appels seront ignorés) */
    Je vous conseille donc d'utiliser plutôt les require, qui sont un peu plus rigoureux.



    Cas d'utilisation

    Les inclusions servent à faire de nombreuses choses, vous pouvez vous en servir selon vos besoins. Mais voici tout de même quelques cas d'utilisation assez fréquents :

    • templating : intégrer des "blocs" extérieur dans une page (exemple : <header> ou <footer>)
    • code HTML redondant (balise <head> par exemple, proche du templating)
    • insertion de librairies / de classes (si vous avez codé des fonctions "utilitaires" utilisées un peu partout dans votre programme par exemple)
    • utilisation de variables "globales" (ex : connexion à une base de données, variables d'environnement,...)
    • script de sécurité (savoir si un utilisateur est logué par exemple : ce script sera présent dans toutes vos pages)
    • etc...


    Conventions : bien souvent, un fichier destiné à être inclut - donc théoriquement inutilisable "seul" - portera le suffixe  .inc. On aura donc des noms avec ce format : monfichier.inc.php.
    Lister les fichiers inclus : vous pouvez lister tous les fichiers inclus dans un script via la fonction get_required_files(). Cela peut être utile, mais c'est clairement moins utilisé que les simples include ou require.

    Note formateur : faire un exo mieux conçu et plus carré

  • Configurer PHP : la gestion des erreurs

    De nombreux paramètres peuvent être configurés dans le php.ini. Afin de pratiquer, nous allons changer le comportement de PHP face aux erreurs qu'il rencontre dans votre application. Ce qui est une chose très commune lorsque l'on configure PHP.

    Lorsque l'on code un programme, on va souvent générer des erreurs de différentes natures :

    • erreur de syntaxe
    • erreur de logique
    • opérations impossibles
    • bugs
    • etc...


    Il est possible en PHP de déterminer comment gérer et afficher ces erreurs. Par exemple, si vous êtes sur un code en production, vous ne souhaiterez pas afficher des petites erreurs "bénignes" (ex : certains warning). En revanche, vous voulez bien les voir dans votre version de développement afin d'en corriger un maximum.

     Donc il y a deux aspects importants à la gestion des erreurs en PHP :

    1. quelles sont les erreurs que l'on souhaite détecter ?
    2. quelles sont les erreurs que l'on souhaite afficher ?


    Ces deux aspects sont configurables via les directives error_reporting et display_errors du fichier de configuration php.ini.

     

     

    Source : lesjoiesducode.fr


    Error reporting

    Cette directive vous permet de régler l'aspect "quelles erreurs doivent être considérées ?". Elle prends comme valeurs plusieurs constantes prédéfinies qui vont vous permettre de gérer plusieurs types d'erreurs :

    • E_ALL : toutes les erreurs et alertes
    • E_DEPRECATED : vous averti d'éléments présents dans votre code qui pourraient être dépréciés dans les versions récentes de PHP (et donc ne plus fonctionner)
    • E_STRICT : averti d'éventuelles modifications à apporter à votre code pour être plus en phase dans les standard (syntaxe, etc...)
    • E_NOTICE : erreurs non-bloquante. Révèlent des instabilités dans votre code.
    • E_ERROR : erreurs importante
    • etc...


    Exemple de directive dans le fichier php.ini :

    error_reporting = E_ALL & ~E_DEPRECATED & ~E_STRICT


    Vous trouverez une liste exhaustive sur la page de la documentation officielle concernant les constantes pré-définies liées à la gestion des erreurs.


    Affichage des erreurs

    Maintenant que vous avez déterminer quels types d'erreurs vous souhaitez faire remonter, vous pouvez décider - ou non - de les afficher dans le rendu de vos scripts (bien souvent, dans votre page web) grâce à la directive display_errors de votre configuration PHP (dans php.ini). Cela vous permet de voir l'erreur directement sur votre page web en un coup d’œil, sans aller chercher dans les logs d'erreurs de votre serveur. Cette directive prends comme valeur 1 ou 0, ou On/Off, selon les cas.

    Exemple php.ini :

    display_errors = On


    Donc si j'écris ce code :

    echo "tralala"   /*Oublie du point virgule, erreur de débutant*/

    J'aurai ce rendu dans le navigateur web :



    De nombreuses autres directives vous permettent d'affiner la gestion des erreurs (voir la documentation). 

    Même si les messages d'erreurs peuvent parfois sembler un peu indigestes à la lecture, il faut vraiment apprendre à les lire rapidement, et en en retirer les informations essentielles en un coup d’œil :

    • timestamp : heure à laquelle c'est arrivé (présent dans les log seulement)
    • type d'erreur (parse, warning, notice,...)
    • détails sur l'erreur (nom de de la fonction, de la variable, de l'instruction,...)
    • nom du fichier dans lequel l'erreur s'est produite (très important si on utilise des require par exemple)
    • numéro de ligne (cela évite de chercher dans le code)
    Attention : lorsque l'on change le contenu du php.ini, il faut normalement redémarrer le serveur web afin que vos modifications soient prises en compte. C'est vrai en local ou en dédié, pas en mutualisé.


    Configuration via une fonction native

    Vous pouvez aussi changer les valeurs des directives de configuration en utilisant des fonctions natives de PHP. Cela peut être plus pratique dans certains cas, mais le mieux reste d'avoir des configurations propres. L'avantage, c'est que ce sera très vite mis en place (pas besoin de modifier le php.ini, ni de redémarrer le serveur). L'inconvénient, c'est que vos réglages ne seront actifs que dans le script en cours d'exécution.

    Exemple :

    <?
ini_set('display_errors', 1);     /* On retrouve bien nos directives, mais les valeur peuvent etre différentes ex : On/1, Off/0) */
ini_set('display_startup_errors', 1);
error_reporting(E_ALL);

...reste du code...

?>

    Log d'erreurs

    Une manière un peu plus "généraliste" de lire les erreurs d'un programme, c'est d'accéder au fichier de log consacré aux erreurs. Ce fichier a un emplacement par défaut réglé dans la configuration de PHP, mais vous pouvez décider d'utiliser un autre emplacement via la directive error_log.


    Dans l'exemple ci-dessus, on utilise la commande linux tail -f sur le fichier de log afin d'afficher les nouvelles erreurs quand elles se présentent. Très pratique pour débugger en "live".
    Si vous êtes emmené à passer du temps sur les logs d'erreurs, il y a aussi des logiciels fait pour ça, qui vous permettent de travailler plus facilement sur ce genre de fichiers parfois difficile à lire ou a manipuler. Cela est un peu plus un travail d'admin en général, mais en tant que développeur, ça peut être utile.

  • Opérateurs spécifiques PHP 7

    Section sur les nouveautés de PHP7. Pas fini. A discuter.


    • opérateur spaceship <=>  (à utiliser dans les fonctions de comparaison dans l'exercice sur les inclusion et le tri des produits)
    • coalescent ??  (exo) (plutot dans les exo get/post)
    • refaire le point sur le typage
    • declare(strict_types=1);  (typage fort)
    • opérateur spread (plutot dans les exo MVC)

  • En plus

    • virtualhost
    • différents réglages sur php.ini
    • phpinfo()