Categories
Apprentissage Formation Framework PHP Web

Symfony

Logo du framework Symfony

L’utilisation d’un framework PHP permet de faciliter la création d’un site/CRUD.
Pendant ma formation, j’ai enfin découvert Symfony 5 !

Symfony, qu’est ce que c’est ?

Comme je l’ai dit, Symfony est un framework PHP. C’est donc un logiciel de construction ou une grosse boite à outils permettant d’aller plus vite.

On y trouve :
– un router : Symfony vient avec son propre serveur web
– des templates
– une structure de projet MVC
– la construction de classes et d’objets facilitée grâce à de nombreuses conventions (notions avancées déjà configurées, qu’on peut implémenter facilement, et qu’il ne faudra pas hésiter à tester !)

Utilisation de Symfony

Créer un nouveau projet

Pour créer un nouveau projet, on utilise alors la commande suivante :

composer create-project symfony/website-skeleton blog

Elle permet de créer toute une architecture de projet sur la base de paquet (ici website-skeleton) dans le dossier choisi.

Il existe 2 types de projets :
skeleton : projet basique sans dépendances. Principalement utilisé pour API, ou pour avancer finement sur un projet.
website-skeleton : projet avec tout le nécessaire pour partir direct avec serveur intégré.

A noter que lorsque l’on utilise un framework, il ne faut pas lui faire confiance à 100% et bien vérifier les fichiers (pour éviter des bugs). Il est donc important de bien lire tous les messages qui apparaissent sur le terminal à la suite d’une installation car ils contiennent de nombreuses informations inintéressantes.

Je vous mets ici une liste pour connaitre un peu plus en détail certains fichiers :
composer.lock : c’est la liste des versions actuelles des extensions utilisées par le projet. Attention : il ne doit jamais être touché !
symfony.doc : c’est la documentation à ne pas toucher;
Kernel : c’est le noyau du projet, on ne le touche pas. A notre niveau, il n’y a pas besoin de le connaitre pour travailler.
Entity : c’est un Model avec juste les attributs, les getter et les setter
repository : ce sont les fichiers qui permettent de faire des select dans un Model. Les requêtes st donc externalisées.
migration : ce fichier contient les modifications successives que l’on fait dans la Base de Données.

Routes

Avec Symfony, il y a deux façons différentes de déclarer les routes :
– soit dans un fichier en .yaml

# config/routes.yaml

about:
    path: /a-propos
    controller: App\Controller\PagesController::about

Dans ce cas on indique à Symfony que la route about se dirigera vers le controller PagesController et utilisera la méthode about associée, lorsque l’utilisateur va sur l’URL /a-propos .

– soit en utilisant les commentaires pour définir les routes directement dans le controller. Attention, il faut bien définir dans l’ordre : la route puis son nom. (voir plus loin dans l’explication des controller)

C’est donc ce choix qu’on privilégiera.
Attention, les 2 façons de faire ne sont pas compatibles !

Controller

Le controller est ensuite créé dans le dossier src/ :

// src/Controller/PagesController.php

namespace App\Controller;

use Symfony\Component\HttpFoundation\Response;

class PagesController {

    public function about() {
        return new Response('Hello world!');
    }
}

Toutes les méthodes de controller retournent impérativement une Response . On utilisera donc l’autocomplétion pour bien importer les alias nécessaires!

return new Response();

C’est alors à ce moment que l’on peut déclarer les routes via les commentaires :

use Symfony\Component\Routing\Annotation\Route;
// ...

    /**
    * @Route("/home", name="home")
    */
    public function home() {
        return new Response ('Bienvenue sur la page d\'accueil !');
    }

Lors de la déclaration des routes, il est possible d’ajouter des variables dans l’URL. La documentation de Symfony est très bien fournie !

/**
* @Route("/users/{userId}/books/{bookId}", name="user_book")
*/
public function users(int $userId, int $bookId) {
    return new Response ('Vous consultez le livre #' . $bookId . ' de l\'utilisateur numéro '. $userId);
}

Il est possible de typer ces variables pour n’accepter que certains types de caractères. Pour cela on va utiliser des expressions régulières (ou regex)

/**
  * @Route("/blog/{page}", name="blog_list", requirements={"page"="\d+"})
  */

Dans ce cas-là, la route n’acceptera que les cas où l’argument {page} correspond à la regex \d+ (= valeurs numériques uniquement).

Note :

Avec Symfony, le var_dump ne permet plus de voir de façon simple les informations. A la place, on fera un dd (dump & die).

Requête (et Réponse)

Lorsque l’on a besoin de récupérer des données d’une requête, on utilise les Request et Response du package HttpFoundation.

use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;

// ...

    /**
    * @Route("/post-user", name="create_user", methods={"POST"})
    */

    public function create(Request $request) : Response
    {
        dump($request);
    }

Nous avons donc déclaré dans la route quelle méthode nous utilisons pour « communiquer » avec la basse de données (ici c’est la méthode POST).
Nous avons aussi importé les classes Request et Response, ce qui nous a permis d’utiliser l’objet Request dans la méthode create().
Il ne faut alors pas oublier d’indiquer le type de retour de la fonction (: Response).

L’objet Request $request, qui par exemple peut être issu de l’envoi d’un formulaire, est alors disponible à l’utilisation !
Nous pouvons ensuite accéder aux valeurs POST par exemple avec $request->get('name');.

Communication avec la base de données

Pour créer une base de données lors d’un projet Symfony, on va utiliser Doctrine.
Doctrine est un ORM (Object-Relational Mapper), qui implémente le pattern Data Mapper. Concrètement, le Data Mapper synchronise un objet dans le PHP avec la base de données, ce qui nous donne une couche Model performante dans notre MVC.

Pour commencer, il faut configurer la base de données dans le fichier .env qui se trouve à la racine du projet :

DATABASE_URL=mysql://db_user:db_password@127.0.0.1:3306/db_name

NB : Remplacez les valeurs de db_user et db_password par les valeurs qui correspondent à votre configuration.

Une fois le fichier .env configuré, on ouvre une console dans le dossier du projet dans laquelle on va saisir : php bin/console doctrine:database:create pour créer la base de données.

Ensuite on va créer une Entity (équivalent du Model en MVC – qui mappera la table correspondante en base de données), en saisissant dans la console : php bin/console make:entity Article

Puis il faut effectuer une migration. Une migration est en fait une instruction de base de données qui indique quoi faire par rapport à l’état des fichiers Entity (elle regarde la BdD et l’Entity puis vérifie la différence entre les deux).

php bin/console make:migration

Il faut ensuite bien aller voir la migration pour vérifier la ligne SQL (et la modifier si nécessaire !). Si tout est OK, on valide en lançant la commande : php bin/console doctrine:migrations:migrate

CRUD & Symfony

Symfony permet aussi de créer facilement un CRUD. Dans chaque Controller, on va pouvoir déclarer toutes les routes correspondant au CRUD, ainsi que les méthodes à utiliser.
Ensuite, on utilisera Twig pour l’affichage de chaque page.

Tout est détaillé dans la doc de Symfony, je vous laisse donc y jeter un œil ! 😉


L’apprentissage de Symfony est un énorme morceau lorsque l’on se plonge dans le Back.
Je vous avouerais que ça n’a pas été ma tasse de thé et je m’excuse d’avance de ne pas avoir détaillé plus tous mes cours…

J’ai enfin fini la formation avec un projet de groupe que je vous laisserai découvrir dans le prochain post ! 🙂

Categories
Apprentissage Formation MVC PHP Web

L’organisation MVC

Le MVC (Model View Controller) est une manière d’organiser son code, de structurer son projet selon un ensemble de conventions.

Fonctionnement

L’idée est de pouvoir séparer le code en différents fichiers dont chacun aura une responsabilité définie. Cela permettra alors de rendre le code plus lisible, plus maintenable et plus prévisible.

schema de mvc (model view controller)
Schéma du Model-View-Controller

Ces différents fichiers sont :

  • les models, qui sont les fichiers qui gèrent la base de données. C’est une classe qui contient des setters, getters, et des fonctions d’enregistrement ou de lecture de la base de données.
    Le fichier est nommé en PascalCase et au singulier, la classe associée prendra alors exactement le même nom.
    Exemple de nommage : Exemple.php qui contiendra : class Exemple { /* */}
  • des views, qui sont les seuls fichiers contenant de l’affichage (HTML) et du code dynamique structurel (des conditions ou des boucles pour l’affichage).
    Le dossier est nommé en kebab-case et au pluriel, il y a alors un fichier par vue.
  • les controllers (glue entre le model et la view) qui, selon la page demandée, récupéreront les données (en demandant au Model correspondant) et afficheront les données (en demandant à la View correspondante).
    Le fichier est nommé en PascalCase et au pluriel, la classe associée prendra alors exactement le même nom.
    Exemple de nommage : ExemplesController.php qui contiendra : class ExemplesController { /* */}

En plus de ces éléments, il y a aussi:

  • un router. C’est un bloc de code (codé manuellement ou grâce à une librairie externe) qui se chargera d’appeler le bon controller selon la page demandée.

Par exemple :

Page demandéeControllerMéthodeCommentaires
"/" en GETAppControllerindex()Relative à l’application en général (AppController). Pour laquelle on veut l’index de l’application
"/a-propos" en GETAppControllerabout()Les pages relatives à l’application en général (AppController), et pour laquelle on veut la page à propos de l’application
"/articles" en GETArticlesControllerindex()Relatives aux articles (ArticlesController), et pour laquelle on veut l’index des articles
"/articles/3" en GETArticlesControllershow(3)Les pages relatives aux articles (ArticlesController), pour laquelle on veut l’affichage d’un article (l’article id = 3)

Comment créer un modèle MVC ?

Il existe de nombreux tutos sur internet. Je vous en ai donc sélectionné quelques-uns :
Tomsihap
Grafikart
Nouvelle Techno
– Kevin Martinel : cours 1 et cours 2

Pourquoi utiliser le MVC

Connaitre l’architecture MVC permet de comprendre le fonctionnement des framework PHP.
En effet, ces derniers sont tous basés sur la logique MVC, ce qui permet une maintenabilité du code plus performante.

Dans un projet en MVC, tout est séparé.
Les URL sont déclarées (par exemple : une route en GET pour voir les formulaires, une route en POST pour le traiter).
Chaque table de la base de données à son propre controller (qui définira via des fonctions les données à transmettre à l’URL pour l’afficher ensuite) ainsi que son propre Model (qui permet de traiter et récupérer les données de la base de données).
Enfin, les vues sont gérées par table de la base de données, et par type d’affichage. Ce sont donc des morceaux de fichiers appelés par le controller au moment de l’affichage.

CRUD

Et si on abordait le sujet du CRUD ? Bonne idée, mais qu’est ce que c’est ? CRUD est l’acronyme de Create, Read, Update et Delete.

Le CRUD permet de faire facilement le lien entre la base de données et PHP. En effet, chaque action visant la base de données est gérée via PHP. On a alors différents fichiers :
– un dédié à la création des éléments de la base de données
– un permettant la lecture (et l’affichage) des éléments de la base de données
– un dédié à la mise à jour de ces éléments
– et enfin, un permettant la suppression d’un (ou plusieurs) élément(s) de la base de données.

Le CRUD s’inscrit donc logiquement dans le fonctionnement en MCV : il permet de bien tout séparer !


Avoir vu le MVC permet de bien compartimenter la façon de fonctionner pour gérer un site en PHP.
L’utilisation d’un framework va permettre d’aller encore plus loin, tout en rendant la création d’un site plus rapide ! C’est ce que nous allons voir par la suite…

Categories
Apprentissage Formation PHP Web

La programmation orientée objet en PHP

Logo PHP

La programmation orientée objet (POO) en PHP est un des cœurs principaux de ce langage. J’ai déjà évoqué ce sujet lors de mon approche de Python. La logique va donc être la même, seul le langage change !

Voyons plus en détail comment PHP utilise la POO.

Les classes

Une classe est une représentation de quelque chose (donnée, container, etc.), c’est un « objet commun ». On peut lui définir un patron de représentation. Et c’est avec ce patron que l’on pourra ensuite générer des objets.

Pour définir une classe, on prépare des attributs (= variables). On peut aussi lui ajouter des méthodes (= fonctions) qui donnent des fonctionnalités par défaut.
On peut ensuite créer une nouvelle instance de la classe (= objet).
A cet objet, on peut ainsi définir des valeurs aux attributs (on utilise la flèche pour l’attribution des valeurs et on ne met pas de $ lors de l’appel de l’attribut).

Dans une classe, pour accéder aux attributs eux-mêmes, on utilise $this. Lors de l’utilisation de la classe, $this sera remplacé alors par le nom de l’objet.
Attention : $this réfère toujours et uniquement à la classe elle-même !

class Table {
    /**
    * Attributs
    */
    public $nom;
    public $plateau;
    public $pieds;

    /**
    * Méthodes
    */
    public function fold() {
        echo "la table " . $this->nom . " est pliée.";
    }
}

$tableKlak = new Table;
$tableKlak->nom = "Klak";
$tableKlak->plateau = "marbre";
$tableKlak->pieds = "acier";

echo "La table " . $tableKlak->nom . " a des pieds en " . $tableKlak->pieds . " et un plateau en " . $tableKlak->plateau
// affichera : La table Klak a des pieds en acier et un plateau en marbre

$tableKlak->fold();
// affichera : La table Klak est pliée.
Les objets

On peut voir les objets comme étant des array surpuissants. Car on peut leur donner des attributs pour être sûrs de ce qu’il y a dedans.
Il y a cependant une grosse différence entre les objets et les arrays : dans un array, on peut rajouter à la volée une nouvelle clé et sa valeur, ou ne pas remplir une clé déjà existante. Avec un objet, on est obligé de prévoir en avance les données qui vont exister, et on sera obligé de ne remplir que celles-ci, et pas une de plus.

Il est aussi possible de mettre des valeurs par défaut aux attributs :

class Table {
    public $nom;
    public $plateau = "plastique";
    public $pieds = 'plastique';
}

On peut définir des attributs ‘obligatoires’. Et pour cela on va utiliser des « méthodes magiques ».
La plus importante est le constructeur car elle est systématiquement appelée lors de la création de l’objet. Cela permet de mettre une surcouche de protection (pour être sûr d’avoir les données nécessaires).

class Table {
    public $nom;
    public $plateau = "plastique";
    public $pieds = 'plastique';

    public function __construct($newName) {
        $this->nom = $newName;
    }
}

$tableKlak = newTable("Klak");

A ce moment il n’y a plus besoin d’instancier l’attribut nom car il le fait automatiquement lors de la création de l’objet.

De manière générale, on ne crée pas une nouvelle variable. On se sert de celles existantes.
Dans l’exemple précédent, on écrirait le constructeur de la façon suivante :

public function __construct($nom) {
    $this->nom = $nom;
}
Les méthodes

Les méthodes sont des fonctions (qui existent dans une classe). Pour créer une méthode, on la déclare dans la classe avec public function :

class Ship {
    public $name;

    public function sayHello() {
        echo "Hello !";
    }
}

Pour appeler une méthode, on utilise la même flèche -> que pour les attributs :

$myShip->sayHello();

Les méthodes permettent donc d’avoir des classes qui sont des petits packs de données, comme un array, mais qui peuvent aussi effectuer des actions, ce qu’un array ne peut absolument pas faire !

Et comme pour une fonction classique, on peut aussi ajouter des arguments à nos méthodes de classe.

Attention, il ne faut pas oublier qu’une méthode doit absolument retourner quelque chose (donc ne pas oublier de mettre un return ou echo) !

La documentation

Lorsque l’on code en programmation orientée objet en PHP, il est de convention chez tous les éditeurs de documenter son code avec phpdoc. Il permet lors de l’autocomplétion dans VSCode (ou tout type d’IDE) d’avoir des informations sur les fonctions, les classes, les variables, etc.

En PHP, on utilise un bloc de commentaires (/**  */) avant la déclaration de la class.
Par exemple pour un constructeur :

/**
* @param string $name Nom du personnage
* @param integer $power Puissance du personnage
*/

Il suffit donc de déclarer : @param (annotation paramètre) suivi du type de données, du nom du paramètre, et éventuellement de ce qu’il représente.

Attention : phpdoc est uniquement de la déclaration et n’a aucune valeur de vérifier les bugs. C’est une aide pour les utilisateurs du code (voir même pour permettre de générer automatiquement une doc)

Pour les attributs, on utilise @var suivi du type de variable (integer, string, boolean).

Gestion des classes

Pour limiter les bugs, l’accès aux données des classes et objets doit être contrôlé.
Dans un premier temps, la déclaration des attributs ne sera plus public mais private :

class Table {
    private $nom;
    private $plateau = "plastique";
    private $pieds = 'plastique';
}

On ne peut alors plus accéder à l’attribut ->nom car il est privé (private). Cela permet donc de ne plus avoir d’erreurs de saisie dans nos objets, par contre on ne peut plus rien mettre dedans du tout.

Pour pallier à ce problème, on va utiliser des getter et des setter. Mais qu’est ce que c’est ?

Getter

Un attribut private, n’est accessible ni en lecture, ni en écriture.
Nous allons donc utiliser des getters, des méthodes qui nous permettent d’accéder aux données de ces attributs.

L’intérêt est d’avoir plus de possibilités, pour formater les données ou pour traduire ce qui vient de la base de données, etc.
Il transforme donc la donnée pour lui permettre de s’afficher.

Par exemple, on peut modifier la casse d’un attribut lors de son affichage :

class Table {
    // ...
    public function getNameUppercase() {
        return strtoupper($this->nom);
    }
}

$maTable = new Table();
echo "TABLE : " . $maTable->getNameUppercase();

// Le nom de la nouvelle table sera écrit en majuscule
Setter

Ce sont des méthodes qui ne servent qu’à une chose : changer la valeur d’un des attributs de notre classe. Le setter prépare donc la donnée.

En fait, quand on met un attribut sur private, on n’y a plus accès depuis l’extérieur de la classe. Par contre, il reste accessible à l’intérieur de la classe ! Un setter permet alors de retourner l’objet lui-même avec return $this ; .

class Table {
    private $nom;
    private $plateau = "plastique";
    private $pieds = 'plastique';

    public function setName($nom) {
        $this->nom = $nom;
    }
}

Le gros avantage des setters, c’est qu’il y a des validations dans nos données. Dans les méthodes set***(), on peut valider les données avant de réellement les donner à nos objets.

Typage

Pour avoir une levée d’erreur, il faut bien penser à typer les paramètres. Par exemple pour le constructeur :

public function __construct(string $newName, int $newStrength = null, int $newPower = null) 
{ 
    // instructions
}

Et pour typer une valeur retour dans une fonction, on l’ajoute au moment de la déclaration :

function maFonction () : int 
{ 
    // instructions
}

Nous avons vu dans les grandes lignes la programmation orientée objet en PHP.
Il nous reste à voir comment bien organiser notre code grâce à la MVC… Ça sera donc le thème du prochain post !!! 🙂

Categories
Apprentissage CSS Database Formation HTML PHP SQL Web

Quand PHP dynamise les pages Web

code sur un écran

PHP dynamise les pages web grâce à des variables injectées directement dans le code HTML des pages.
Découvrons ce qui se cache derrière ces variables dites dynamiques…

Les superglobales

Une page web contient de nombreuses données qui peuvent être récupérées en PHP. Pour cela on va utiliser des variables techniques dites superglobales. Elles sont toujours disponibles, quel que soit le niveau où elles sont déclarées.

SuperglobaleDescription
$GLOBALSListe les variables disponibles dans le contexte global de l’application
$_SERVERContient des informations comme les en-têtes, dossier, chemin du script. Informations générées par le serveur
$_REQUESTUn tableau associatif qui contient par défaut le contenu des variables $_GET$_POST et $_COOKIE.
$_POSTContient les variables POST passées via une requête HTTP
$_GETElle contient les variables GET passées via une requête HTTP
$_FILESElle contient les fichiers uploadés au serveur passés par la méthode POST
$_ENVContient les variables d’environnement qui gravitent autour du script PHP : les variables shell, le système d’exploitation…
$_COOKIETableau de cookies envoyés par HTTP
$_SESSIONTableau de valeurs stockées en session, c’est-à-dire n’existant que pour l’utilisateur courant et durant une période limitée (son temps de connexion environ par défaut)

La transmission des données d’une page à l’autre se fait via le protocole HTTP. Deux méthodes sont alors utilisées :
GET : qui permet de récupérer un contenu, transmis par un paramètre get via l’URL.
POST : qui permet d’envoyer plus de contenu. Cette méthode est principalement utilisée pour gérer l’envoi de formulaires (lien avec HTML).

Voyons ces deux superglobales en détail…

Les variables GET

Lors d’une requête GET, on peut créer des variables directement dans l’adresse URL. La transmission se fait alors avec une paire de key=value contenue dans l’URL. Les données sont donc récupérables.
Pour ce faire, à la fin de l’adresse on écrit : url?parametre1=valeur1&parametre2=valeur2

Attention, le ? entre le nom du fichier et la variable est très important car c’est lui qui détermine les variables à transmettre.

Pour récupérer les données, on utilisera ensuite la superglobale $_GET.
Cette variable est un tableau d’objets qui contient toutes les données sous le format key => value .

Les variables POST

La méthode POST est principalement utilisée pour les formulaires. Pour gérer ces données, il faudra avoir 2 pages : une page contenant le formulaire et une autre permettant le traitement des variables.
La superglobale $_POST se comporte exactement comme $_GET : elle revoie un tableau d’objets. Il ne faut donc pas oublier dans le formulaire d’ajouter à chaque input un name !

Par exemple :
Page form.php

<html>
<body>
    <form action="login.php" method="post">
        <input type="email" placeholder="Adresse e-mail" name="email">
        <input type="password" placeholder="Mot de passe" name="password">
        <button type="submit">Connexion</button>
    </form>
</body>
</html>

Page traitement.php

<?php

echo "Votre e-mail est " . $_POST['email']  . ". Vous êtes bien connecté ! Votre mot de passe est secret, mais au cas où, il s'agit de " . $_POST['password'];

?>

Utiliser PHP avec du HTML, c’est possible !

Dans le doc HTML, on va pouvoir considérer les données PHP comme étant des données dynamiques. Il va donc être possible d’ajouter des conditions, ou des boucles directement dans le HTML.
Pour cela, on va inclure les données PHP en les écrivant dans les balises PHP : <?php   ...    ?> .

Les bonnes pratiques :
<?= correspond à <?php echo. Cette notation va permettre d’abstraire encore plus le php !
– au lieu de l’accolade dans les conditions, on va mettre deux points et terminer avec end... .
Par exemple :

<?php foreach($articles as $article => $donnee) : ?>
    <div>
        <a href="article.php?id=<?= $article ?>"><?= $donnee['title'] ?> </a>
        </div>
<?php endforeach ; ?>

On va donc écrire toute la page en HTML. Et s’il y a des variables spécifiques à déclarer en PHP, on va créer un bloc PHP tout en haut du document (avant la déclaration du HTML).

Conseils pratiques :
– avant de mettre les variables PHP dynamiques, écrire d’abord en dur le HTML ce que l’on veut obtenir,
– ne pas oublier d’ouvrir et fermer directement la balise PHP pour éviter les problèmes.

Insertion de fichier

Il est aussi possible d’insérer des fichiers directement dans la page PHP/HTML. Pour cela, on va utiliser la fonction include( ) (ou required() ).

PHP va lire le fichier, prendre tout son contenu pour le copier dans la page HTML. A noter que toute cette partie n’apparaîtra pas dans le code source : le fichier va rester sur serveur, et PHP va l’analyser pour le compiler (tout en restant transparent pour le client !).

Cette fonction d’ajout permet aussi de gérer les fichiers comme les componants externes : on peut faire un fichier contenant juste la navbar, juste le header, juste le footer, etc…
Cela évite d’écrire la même chose de partout, et les changements seront alors plus simples.
Le code PHP de la page web devient donc plus facile à maintenir !

Différence entre include et required

Avec include( ) , si le fichier n’est pas trouvé, on aura un warning (cela n’empêche donc pas le script de s’exécuter).
A noter que les erreurs ne s’affichent pas pour les clients du site, elles s’affichent uniquement en mode développeur.

Avec require( ) , si le fichier n’est pas trouvé, on aura alors une fatal-error entraînant l’arrêt d’exécution du script !

Connexion avec les bases de données

Il est possible de récupérer les données depuis une base de données. Pour cela, il faut créer une connexion à la base de données ($bdd), puis créer une requête comme avec SQL ($response), pour ensuite avoir une réponse ($variablesRecuperees).

Extraire tous les éléments de la base de données
// On créée une connexion à la base de données que l'on stocke dans $bdd
$bdd = new PDO('mysql:host=localhost;dbname=nomDeLaBdd;charset=utf8;port=3306', 'login', 'password');

// On écrit notre requête MySQL. On peut aussi concaténer des variables PHP dedans si besoin !
$request = "SELECT * FROM table";

// On demande à notre base de données, $bdd, d'exécuter la requête. On stocke la réponse de MySQL dans $response 
$response = $bdd->query($request);

// On demande à la réponse de nous retourner TOUTES les données (grâce à fetchAll).
// De plus, ces données seront retournées sous forme de tableau associatif, grâce au paramètre PDO::FETCH_ASSOC. 
$variablesRecuperees= $response->fetchAll(PDO::FETCH_ASSOC);

$variablesRecuperees est alors un tableau associatif. On peut alors extraire toutes les données grâce à un foreach :

<?php foreach ($variablesRecuperees as $variableRecuperee) : ?>
  <h1>
      L'élément est <?= $variableRecuperee['champs'] ?>
  </h1>
<?php endforeach; ?>
Extraire un seul élément

Il est possible d’extraire un seul élément de la base de données.
Pour cela, il existe deux façons de faire :

1 – en cherchant via l’id de l’élément (ou en incluant des variables précises)
Par exemple :

$idMovie = 34; // cet ID peut venir de GET par exemple !
$request = "SELECT * FROM movies WHERE id = " . $idMovie;

// ou encore

$search = "science-fiction"; // Ce paramètre peut venir de GET si on a cliqué sur le lien d'une catégorie, ou de POST pour un moteur de recherche par exemple !
$request = "SELECT * FROM movies WHERE category LIKE '%" . $search . "%'";

2 – via une requête paramétrée

$response = $bdd->query($request);

// Si on n'attend qu'un élément (par exemple: un film trouvé par ID), on utilise fetch :
$variableRecuperee = $response->fetch(PDO::FETCH_ASSOC);

PHP aide à dynamiser les pages web en injectant des données qui sont modifiables en fonction contexte.
Mais PHP est avant tout un langage de programmation orienté objet !
Nous découvrirons la POO avec PHP dans les prochains cours !

Categories
Apprentissage Formation HTML PHP Web

La programmation en PHP

Logo PHP

La programmation en PHP courante se fait comme en JS : des boucles, des conditions, des fonctions…
Allons voir de plus près !

Dans cet article, je vais faire beaucoup de liens avec JavaScript. En effet, la réflexion de programmation est toujours la même. Seule la syntaxe change d’un langage à l’autre…
Je ne détaillerais donc pas tout. Toutefois, vous pouvez trouver quelques explications sur les articles écrits lors de mon apprentissage du JS :
pour les variables et tableaux
pour les fonctions

Conditions

IF

La structure est la suivante :

if (condition) {
    echo "Condition vraie";
}
elseif (condition2) {
    echo "2ème condition vraie";
}
else {
    echo "Condition fausse";
}

Attention : PHP va considérer que tout ce qui n’est pas équivalent à 0 est vrai et tout ce qui l’est est faux.

Le résultat d’une condition va être interprétée par PHP comme une variable booléenne. Il va chercher à chaque fois à déterminer si la condition est vraie ou fausse.
Lorsque l’on utilise un double égal, PHP va essayer de trans-typer les variables pour les comparer entre elles. Il est alors nécessaire d’utiliser le triple égal (que l’on utilisera donc par défaut).

Avec if, tout ce qui se passe dans le bloc, sort du bloc et est alors récupérable.

AutreS manièreS d’écrire :

l’écriture ternaire
Tout comme en JS, on met l’action à effectuer avant la condition :

echo (condition) ? "si vrai" : "si faux" ;
// ou
$variable = (condition) ? "si vrai" : "si faux" ;

On l’utilisera peu car en intégrant les conditions dans du HTML, la lecture et l’écriture ne seront alors pas aisées.

le switch
Il est utilisé lorsqu’il y a plusieurs choix possibles (comme en JS).
On passe alors successivement par toutes les étapes.
S’il n’y a pas de break, la lecture des cas continue. S’il y a un break, cela permet de sortir de la condition.
Le résultat de chaque case est fixe car on vérifie une égalité simple.

OU / ET

L’écriture de ces opérateurs est la suivante :
OU => OR ou ||
ET => AND ou &&

Leur utilisation est la même qu’en JS.

Les tableaux

Array simple

Ils permettent de stocker dans une variable plusieurs données.
Il y a deux façons d’écrire un tableau :

$array = ["a", true, 42, $variable, ["autre tableau"]]; // date de PHP5.3 - 2009
$array = array(); // avant 2009 - ne pas s'en servir !

A noter : echo permet uniquement d’afficher des string ou variable simple. Par contre, il ne permet pas afficher un tableau.
Pour afficher les infos du tableau, on utilisera donc var_dump( )

Pour afficher une donnée du tableau, on utilise son index (se comporte comme en JS)

echo $array[0];
Tableau associatif

Au lieu d’utiliser les index, on associe une clé à une valeur. Le tableau simple devient alors un tableau associatif.
Pour associer la clé à la valeur, on va utiliser une grosse flèche : =>

$user = [
    "firstname" => "john",
    "lastname"  => "doe",
    "age"       => "54",
    "job"       => "developpeur"
];

Pour afficher une donnée du tableau associatif, on utilise alors sa clé :

echo $user["job"];

Les boucles

Les boucles dédiées aux tableaux

Pour pouvoir lire successivement les données dans un tableau, on va utiliser une boucle spécifique : foreach(argument) {}

foreach($tableau as $elementsDuTableau) {
    //instructions;
}

La boucle va alors scanner tous les éléments du tableau et les instructions porteront sur ces éléments.
Par exemple :

$nbPairs = [2, 4, 6, 8];

foreach($nbPairs as $nombre) {
    echo $nombre;
}

// écrira : 2 puis 4 puis 6 puis 8

$user = [
    "firstname" => "john",
    "lastname"  => "doe",
    "age"       => "54",
    "job"       => "developpeur"
];

foreach($user as $cle => $valeur) {
    echo "<li>" . $cle . " : " . $valeur . "</li>";
}

// écrira sous forme de liste chaque clé puis ":" puis chaque valeur associée

Conventions
Le singulier et le pluriel sont très importants lors de la désignation des variables :
– le singulier représente 1 seule chose
– le pluriel représente plusieurs choses (comme par exemple pour un tableau simple qui contient 2 tableaux)

Les boucles while

Les boucles while fonctionnent en PHP comme en JS…

$i = 0;

while($i < 10) {
    var_dump($i);
}

Dans l’exemple ci-dessus, la boucle est infinie.

En PHP, le navigateur ne se crashe pas car le serveur (Apache) va stopper l’exécution . En effet, le serveur limite les capacités de mémoire au client ce qui permet de ne pas le faire planter lorsqu’une boucle infinie est exécutée…
Il y a donc 2 limites par défaut qu’on peut paramétrer dans le fichier php.ini
– un temps d’exécution de 30sec max
– la mémoire allouée de 128Mo

Pour stopper une boucle infinie, il faut alors stopper le serveur et le relancer !

$i = 0;

while($i < 10) {
    var_dump($i);
    $i = $i + 1;
}

Il y a trois manières d’écrire l’incrémentation de la boucle :
$i = $i + 24
$i += 24
$i++ (rajoute uniquement 1) / On préférera cette notation sauf quand l’incrémentation est différente de 1.

L’ordre d’écriture de la boucle est important. En effet, selon le placement de l’incrémentation, le résultat obtenu ne sera pas le même.

$i = 0;

while($i < 10) {
    var_dump($i);
    $i++;
}

// on va de 0 à 9
$i = 0;

while($i < 10) {
    $i++;
    var_dump($i);
}

// on va de 1 à 10

La boucle while vérifie une vérité, il n’y a donc pas forcément besoin d’une incrémentation. On peut parcourir une liste par exemple.

Les boucles for

Les boucles for fonctionnent aussi en PHP comme en JS…

for($i = 0; $i < 10; $i++) {
    var_dump($i);
}

On va privilégier cette boucle.

Demander des nombres pairs

Pour vérifier qu’un nombre est pair, on va passer par un modulo pour être sûr du résultat. Et ce, quelque soit la valeur initiale de la variable testée.

for($i = 0; $i < 10; $i++) {
    if($i%2 === 0) {
        var_dump($i);
    }
    $i++;
}

Les fonctions

C’est un bloc contenant une série d’instructions qui pourra être rappelé lorsque l’on en a besoin. Cela évite de se répéter, évite les erreurs et que l’on peut l’utiliser à différents endroits.
Il permet lorsqu’il y a une modification à faire (lors de la maintenance par exemple) d’avoir un seul endroit à modifier (et évite de chercher de partout!).

Si à un moment on recopie au moins 2 fois la même chose, il faudra bien se poser la question si cela mérite ou non une variable ou une fonction.

Une fonction est un répertoire, une recette de cuisine. Tant qu’on ne l’exécute pas (on ne l’appelle pas), les instructions contenues à l’intérieur restent en « sommeil ».

Dès qu’on appelle une fonction, elle va alors juste exécuter les instructions.
Il faut donc obligatoirement demander à la fonction de retourner quelque chose pour qu’elle puisse afficher un résultat.

//déclaration
function sayHello() {
    //instructions
    $texte = "hello world";
    return $texte;
}

//appel
echo sayHello();

Attention, dans les instructions on va éviter de mettre des instructions d’affichage. Ce qui permet de décider par la suite ce que l’on veut faire du résultat de la fonction.

PORTÉE DES VARIABLES

En général, les variables déclarées dans un bloc de fonction ne sont utilisables que dans ce bloc. C’est ce que l’on appelle la portée des variables (ou scop). le scop global correspond à ce qui se trouve partout dans le code (hors d’un bloc).

Les variables sont utilisables de partout (même dans des blocs de conditions par exemple).

Dans les blocs de conditions ou de boucles, dès que l’on rentre dedans on peut récupérer toutes les variables après.

Les fonctions elles, n’ont pas accès au scop global. On ne peut donc pas utiliser de variables externes dans une fonction. Et inversement, les variables de la fonction ne peuvent pas être utilisées après l’exécution de la fonction.
C’est pour cette raison qu’on utilise return pour récupérer une variable de fonction dans le scop global.

Les paramètres (ou arguments)

Il est possible d’attribuer des paramètres (ou arguments) à une fonction.

function addition($nombre1, $nombre2) {
    $calcul = $nombre1 + $nombre2;
    return $calcul;
}

echo addition(42, 58);

Cet exemple permet de montrer que, quelque soit les paramètres que l’on va mettre dans la fonction, on aura un résultat.

Les fonctions récursives

Une fonction récursive est une fonction qui s’appelle elle-même.
Par exemple une fonction qui prend un nombre $nombre et additionne tous les nombres un par un jusqu’à ce nombre :

function somme($nombre) {
    // Si mon nombre est différent de zéro, je fais mon calcul :
    if ($nombre != 0) {
        // La somme est :
        // le nombre actuel +
        // la fonction somme() sur le nombre précédent
        // Qui elle même prend le nombre précédent...
        // Et lui ajoute la fonction somme sur le nombre encore précédent...
        // et ainsi de suite !
        $somme = $nombre + somme($nombre - 1);
        return $somme;
    }
    else {
        return $nombre;
    }
}

On vient de faire un tour rapide des fonctionnalités de PHP qui nous servirons ensuite lors de son utilisation pour les page web.
D’ailleurs, en parlant pages web, comment PHP permet de les dynamiser ?
C’est ce que j’ai découvert dans la suite des cours…

Categories
Apprentissage Formation HTML PHP Web

Langage PHP

Logo PHP

Après avoir vu comment gérer une base de données, nous apprenons un nouveau langage : PHP.
Plus connu sous son sigle PHP (Hypertext Preprocessor), est un langage de programmation qui est principalement utilisé pour produire des pages Web dynamiques via un serveur HTTP.

Généralités

PHP va compiler et transformer les fichiers en HTML (ou autre) en petits exécutables qui ne sont pas lisibles tel quel. On va donc utiliser un serveur Web (Apache, Ngnix, etc.) pour les afficher.

Pour travailler en PHP, il faut donc :
– un exécutable PHP (outil en ligne de commande) qui permet de lire et compiler les requêtes,
– un serveur web (Apache par ex.) qui est capable de lire les fichiers compilés par PHP.

Les versions de PHP

Créé en 1994 par Rasmus Lerdorf, PHP a connu plusieurs rénovations. La plus utilisée est PHP5 qui a été mise en place en 2005.
Depuis il y a eu beaucoup de tentatives de rénovation de PHP. En 2005, la sortie de PHP6 n’a pas marché.

Il a fallu attendre 2015 et l’arrivée de PHP7 pour une remise à plat et une ré-écriture complète de tout le langage. Ce qui a permis notamment de doubler les performances. La contrainte fût une mise à jour massive et rapide des sites codés en PHP5… Depuis, ces mises à jour sont plus régulières et plus stables.

Pour en savoir plus, il suffit d’aller faire un tour sur Wikipédia ! 😉

Alors PHP ça ressemble à quoi ?

Rentrons dans le vif du sujet…
PHP peut s’intégrer partout dans du HTML et permet de travailler avec des variables directement dans la page.
Pour cela il suffit d’ouvrir une balise de code PHP :

<?php

?>

A noter que quand on écrit un fichier uniquement en PHP et qu’il n’y a rien d’autre, on n’est pas obligé de fermer la balise PHP ?> .

Et il est important de retenir que toutes les instructions finissent avec un point-virgule. Sinon, elles ne marchent pas !

Les variables
Déclaration

La déclaration se fait avec un dollar : $nomVariable
Pour le moment, on typera les variables uniquement grâce à la valeur qu’on leur donnera. Il faut bien retenir que PHP est très permissif dans le typage des variables.

Concaténation

On peut concaténer les variables entre elles avec un point :

$hello = "Hello";
$world = "World";

$result = $hello . $world;

Une autre façon de faire :

$stringAge = $stringAge . "ans"
//ou 
$stringAge .= "ans"

Il est aussi possible de faire des calculs :

$calcul = $number + 14; 
// les opérateurs possibles sont : + - / * %
Affichage

On va utiliser echo, puis on déclare derrière tout type de données (chiffres, caractères, variables, HTML).

Si on déclare plusieurs echo les uns à la suite des autres, toutes les valeurs seront mises les unes à côté des autres (chiffre et caractères indifféremment).
Il est possible d’ajouter du HTML entre, il suffit de bien ouvrir et fermer les balises PHP comme il faut.

Divers
  • var_dump( ) permet quant à lui de débugger.
    Il va afficher : à quel endroit il y a l’erreur, quel type de donnée est à l’origine de l’erreur et sa valeur.
  • ! quand on le met devant un booléen, il permet d’avoir l’inverse.

Hello World

Premiers essais, premières lignes de code… Affichons « Hello World » !

<?php
echo 'Hello World';
?>

Dans la suite des cours, nous verrons comment utiliser le langage PHP en programmation