Introduction

L'écosystème PHP est vaste et complet : beaucoup d'outils, frameworks et CSM sont disponibles, la communauté est importante et active, les entreprisent recrutent, les clients sont nombreux…. Dans un monde faisant intervenir autant d'acteurs, il est important de suivre certaines "normes" afin d'assurer la pérénité des projets (et du langage). Ces conventions ont pour but de fournir des bonnes pratiques afin d'homogénéiser les développements et de simplifier la maintenabilité du code. En effet, un projet PHP qui repsecte les normes est plus facile à prendre en main par un nouveau développeur et ainsi plus simple à maintenirqu'un projet ne les respectant pas.

Il existe 3 grands standards PHP :

Je vais, dans cet article, parler de la convention PSR qui tend à devenir le standard respecté par Symfony notamment. 

Les normes PSR

PSR-0 : autoloading

L'objectif de la PSR-0 est de rendre standard le chargement des classes afin d'éviter les "include" et "require". Ce système d'autoloading repose sur la bonne utilisation des namespaces. Voici la liste des principales règles :

  • Les classes et les espaces de noms entièrement qualifiés doivent disposer de la structure suivante\<Nom du Vendor>\(<Espace de noms>\)*<Nom de la Classe>.
  • Chaque espace de noms doit avoir un espace de noms racine. ("Nom du Vendor").
  • Chaque espace de noms peut avoir autant de sous-espaces de noms qu'il le souhaite.
  • Chaque séparateur d'un espace de noms est converti en DIRECTORY_SEPARATOR lors du chargement à partir du système de fichiers.
  • Chaque "_" dans le nom d'une CLASSE est converti en DIRECTORY_SEPARATOR. Le caractère "_" n'a pas de signification particulière dans un espace de noms.
  • Les classes et espaces de noms complètement qualifiés sont suffixés avec ".php" lors du chargement à partir du système de fichiers.
  • Les caractères alphabétiques dans les noms de vendors, espaces de noms et noms de classes peuvent contenir n'importe quelle combinaison de minuscules et de majuscules.

Le fichier d'autoload généré est par Composer, par exemple, respecte cette norme.

PSR-1 : La norme de codage de base

La PSR-1  décrit les éléments standards de codage nécessaires pour assurer un niveau élevé d'interopérabilité technique pour le partage du code PHP. Cette norme concerne : les fichiers, les espaces de nom et noms des classes ainsi que les constantes de classe, propriétés et méthodes :

  • Les fichiers DOIVENT utiliser seulement les tags <?php et <?=.
  • Les fichiers de code PHP DOIVENT être encodés uniquement en UTF-8 sans BOM.
  • Les fichiers DEVRAIENT soit déclarer des symboles (classes, fonctions, constantes, etc.) soitcauser des effets secondaires (par exemple, générer des sorties, modifier paramètres .ini), mais NE DOIVENT PAS faire les deux.
  • Les espaces de noms et les classes DOIVENT suivre PSR-0.
  • Les noms des classes DOIVENT être déclarés comme StudlyCaps.
  • Les constantes de classe DOIVENT être déclarées en majuscules avec un sous-tiret en séparateurs.
  • Les noms des méthodes DOIVENT être déclarés comme camelCase.

Vous trouverez des exemples concrets ici : http://www.php-fig.org/psr/psr-1/fr/.
Personnellement je trouve que cette règle est importante est doit être respectée au maximum car elle améliore la lisibilité du code.

PSR-2 : Guide pour le style d'écriture de code

La norme PSR-2 complète la PSR-1 et décrit les bonnes pratiques en matière de programmation. Vous trouverez ci-dessous la vue d'ensemble des points décrit dans la documentation officielle :

  • Le code DOIT suivre les PSR-1.
  • Le code DOIT utiliser 4 espaces pour l'indentation et aucune tabulation.
  • Il NE DOIT PAS exister une limite stricte sur la longueur de la ligne, la limite acceptable DOIT être de 120 caractères; les lignes DEVRAIENT comprendre 80 caractères ou moins.
  • Il DOIT y avoir une ligne vide après la déclaration de l'espace de noms, et il   DOIT y avoir une ligne vide après le bloc de déclarations use.
  • L'ouverture des accolades pour les classes DOIT figurer sur la ligne suivante, les accolades de fermeture DOIVENT figurer sur la ligne suivante après le corps de la classe.
  • L'ouverture des accolades pour les méthodes DOIT figurer sur la ligne suivante, les accolades de fermeture DOIVENT figurer sur la ligne suivante après le corps de la méthode.
  • La visibilité DOIT être déclarée sur toutes les propriétés et méthodes; abstract et finaldoivent être déclarés avant la visibilité; static DOIT être déclaré après la visibilité.
  • La structure des mots-clés de contrôle DOIT avoir un espace après eux, les méthodes et les appels de fonction NE DOIVENT PAS en avoir.
  • L'ouverture des accolades pour les structures de contrôle DOIT figurer sur la même ligne, et la fermeture des accolades DOIT figurer sur la ligne suivante après le corps.
  • l'ouverture des parenthèses pour les structures de contrôle NE DOIT PAS contenir d'espace après eux, la fermeture de parenthèses pour les structures de contrôle NE DOIT PAS contenir d'espace avant.

Cette convention est souvent controversée car elle est considérée comme trop "rigide". De mon point de vue, il faut adopter une règle est la respecter. Ainsi, si vous intervenez sur des projets déjà avancés, calquez vous sur ce qui est déjà en place (notamment pour les accolades et l'indentation). Le principal étant simplement de rester cohérent avec l'implémentation déjà effectuée et la méthodologie adoptée par les développeurs travaillant sur le projet.

PSR-3 : Interface pour les logs

L'objectif de la PSR-3 est de définir comment seront gérés les logs de votre application. Comme dans la majorité des cas vous utilisez une librairie dédiée au log, le plus simple est d'en choisir une répondant à cette norme 😉 telle que Monolog par exemple. Voici les concepts de base :

  • L'interface LoggerInterface expose huit méthodes pour écrire les logs pour les huit RFC 5424levels (debug, info, notice, warning, error, critical, alert, emergency).
  • Un neuvième méthode, log, accepte un niveau de journalisation en tant que premier argument. L'appel de cette méthode avec l'une des constantes du niveau de journalisation DOIT avoir le même résultat que l'appel de la méthode de niveau spécifique. L'appel de cette méthode avec un niveau non défini par cette spécification DOIT lancer un Psr\Log\InvalidArgumentException si l'implémentation ne reconnaît pas le niveau. Les utilisateurs NE DEVRAIENT PAS utiliser de niveau personnalisé sans savoir avec certitude si l'implémentation le supporte.

PSR-4 : autoloading avancé

Cette norme complète la PSR-0. Alors que cette dernière se concentre principalement sur les namespaces et noms de classes, la PSR-4 fixe des règles concernant l'arborescence des fichiers. Vous trouverez plus d'informations ici : http://www.php-fig.org/psr/psr-4/.

Le fichier d'autoload généré par Composer, par exemple, respecte également cette norme (en plus de la PSR-0).

Quelques outils

PHP Coding Standards Fixer : développé parSensio Labs (Symfony) pour passer du code aux normes PSR

https://github.com/duodraco/phpcs-psr : un jeu de règles pour PHP Code Sniffer (phpcs)

Conclusion

Dans le cadre d'un processus d'intégration continu, vous pouvez envisager d'utiliser les hook de pré-commit afin de forcer les développeurs à respecter certaines des conventions ci-dessus. Ainsi, si le code n'est pas "PSR compliant",  le développeur devra l'adapter afin de pouvoir commiter.

Cet article est une simple introduction à la norme PSR. Si vous êtes pour ou contre les conventions, si vous souhaitez apporter des informations complémentaires, si vous préférez une autre convention que la PSR ou bien tout simplement si vous souhaitez vous exprimez : laissez un petit commentaire ci-dessous.

Si vous n'êtes pas fan des expressions régulières et que vous souhaitez simplement valider une adresse mail, voici une solution simple :

$email = 'nom.prenom@domain.com';
if (!filter_var($email, FILTER_VALIDATE_EMAIL)) {
    echo "Adresse e-mail non valide.";
}

Et pour valider une URL :

$url = "http://severin-bruhat.com";
if (!filter_var($url, FILTER_VALIDATE_URL)) {
    echo "URL non valide.";
}

Je vous invite à jeter un oeil à cette page de la documentation offcielle afin de découvrir une multitude de filtres qui vous éviteront d'implémenter manuellement certaines méthodes (suppression de certains caractères dans une chaine par exemple).

Si vous n'avez pas encore entendu parler de Composer, ou si vous vous demandez de quoi il s'agit : cet article est pour vous.

Présentation

Composer est un gestionnaire de dépendances de plus en plus utilisé pour les projets PHP. Si vous souhaitez installer un package, Composer se chargera automatiquement d'installer les autres paquets dont il dépend. Vous connaissez peut-être PEAR qui est également un gestionnaire de paquets ; c'est un outil équavalent mais vieillissant. En combinant l'utilisation de Composer avec votre outil de versionning, vous aurez la certitude de disposer de la même stack sur tous vos environnements. Ainsi, chaque développeur aura la même version des librairies du projet sur lequel il travaille. 

composer

Installation

Composer est distribué sous la forme d'un phar, vous pouvez le récupérer via la commande suivante :

	curl -sS https://getcomposer.org/installer | php

Petite astuce pour rendre l'installation "globale" : 

    sudo mv composer.phar /usr/bin/
    vim ~/.bash_profile
    alias composer="php /usr/bin/composer.phar"

Après avoir relancé le terminal, vous pourrez exécuter Composer à l'aide de la simple commande "composer". Sans cette manipulation, pour lancer l'outil, positionnez vous dans le dossier où vous l'avez téléchargé et exécutez la commande "php composer.phar".

Vous trouverez plus de détails concernant l'installation de Composer dans la documentation officielle.

Utilisation

Pour utiliser Composer, vous devez d'abord créer un fichier nommé composer.json. Ce fichier listera l'ensemble des fichiers à télécharger et devra se trouver à la racine de votre projet. Vous trouverez la liste complète des packages disponibles sur packagist.org. Prenons un exemple : si vous souhaitez installer silex et monolog voici à quoi ressemblera le fichier composer.json :

{
    "require": {
      "silex/silex": "dev-fat-13157",
      "monolog/monolog": "1.9.*"
    }
}

Une fois le fichier en place, installez les dépendances à l'aide de la commande suivante :

php composer.phar install

Votre projet contient maintenant :

  • un fichier composer.lock : liste les packages et versions installées
  • un dossier vendor : contient les sources des  packages

Dans votre workflow de développement, le dossier "vendor" ne doit pas être versionné, en revanche, les fichiers composer.lock et composer.json doivent l'être.

La commande "install" permet d'installer les versions des packages désirées (1.9.1 par exemple). Une fois les fichiers "composer.json" et "composer.lock" versionnés, chaque développeur devra lancer la commande "install" pour installer les packages et leurs dépendances. Si vous souhaitez mettre à jour la version d'un package, il faut exécuter la command "update" (afin de récupérer la version 1.9.2 par exemple),  c'est plutôt le rôle du lead dev (ou de l'architecte). Une fois la mise à jour validée, ce dernier commitera les fichiers et chaque développeur devra passer la commande "install" qui exécutera l'installation des packages à la version fixée dans le fichier "composer.lock".

Autoloading

Composer génère un fichier "autoload.php" (vendor/autoload.php) que vous pouvez inclure dans vos projets afin de manipuler les packages installés :

require 'vendor/autoload.php';

Cet autoload est bien réalisé et repsecte le standard PSR-0, je vous conseil donc de l'utiliser, à moins que vous ne disposiez déjà d'un autoload dans votre projet.

Cettte petite présentation de Composer est terminée. N'hésitez pas à apporter un retour d'exépérience en commentant cet article. Vous trouverez une cheat sheet contenant les commandes ici : http://composer.json.jolicode.com/.

Je suis récemment tombé sur cet article http://www.sitepoint.com/mysql-mistakes-php-developers listant quelques bonnes pratiques concernant MySQL. J'ai trouvé ce post intéressant et souhaite donc le partager avec vous (l'approche est un peu différente de l'article original).

Utiliser InnoDB plutôt que MyISAM

Par défaut, lorsque vous créez une base de données MySQL, celle-ci est au format MyISAM, c'est dommage ! En effet, MyISAM ne gère ni les clés étrangères, ni les transactions. MyISAM lock aussi complètement les tables en cas d'insertion ou de mis à jour, ce qui est "sécurisant" mais coûteux en terme de performance.

Préférez donc InnoDB qui présente les avantages suivants :

  • modèle ACID : atomicité, cohérence, isolation et durabilité (plus performant que le système de lock de MyISAM)
  • supporte les transactions
  • support les clé étrangères
  • permet les sauvegardes à chaud

C'est bien connu : pas d'avantages sans inconvénients ! Ainsi, InnoDB est plus complexe à administrer que MyISAM. Vous trouverez la procédure permettant d'activer le mode InnoDB par défaut et de migrer vos table de MySIAM vers InnoDB ici.

Utiliser l'extension PHP Mysqli

Depuis la version 4.1+ de mysql, il est préférable d'utiliser mysqli (MySQL Improved) pour communiquer avec la base de données. Les principaux avantages de cette extension sont les suivants :

  • interface (optionnelle) orientée objet
  • utilisation de requêtes préparées  : amélioration de la sécurité et des performances
  • support des transactions

Vous trouverez la documentation officielle à cette adresse : http://www.php.net/manual/fr/book.mysqli.php.

Sécuriser les inputs

Il est nécessaire de valider toutes les variables reçues côté PHP avant de les insérer dans une requête afin de limiter les risques d'injection SQL du type :

$username = $_POST["name"];
$password = $_POST["password"];
$sql = "SELECT userid FROM usertable WHERE username='$username' AND password='$password';";
// run query...

Imaginons que $_POST[« name »] ait pour valeur : "admin'; –" la requête envoyée au serveur MySql sera la suivante :

SELECT userid FROM usertable WHERE username='admin';

ET voilà, l'utilisateur sera connecté en admin dans le cas d'une requête utilisée pour une authentification. Il faut savoir que généralement, les frameworks et CMS gèrent automatiquement ce type d'injection en échappant certains caractères par exemple. Si vous devez faire les tests manuellement, voici 2 petites actuces :

  • appliquer la méthode mysql_real_escape_string() au chaines de caractères
  • vérifier le entiers / numériques grâce à la méthode intval()

Utiliser UTF-8

Pensez à utiliser le charset utf-8, notamment dans le cadre de projets multilingues.

CREATE DATABASE `mabase` CHARACTER SET utf8 COLLATE utf8_general_ci;

Bon côté PHP, vous allez me dire "oui mais moi avec ces histoires d'encodage je galère à chaque fois", patience, PHP 6 devrait régler ce problème.

Préférer un traitement SQL plutôt que PHP

En tant que développeur, vous préfèrez coder une moyenne en PHP plutôt que d'utiliser la petite fonction AVG de MySQL ? Erreur, il est plus performant de traiter ce cas côté MySQL. Songez donc à étudier la documentations MySQL pour vérifier s'il est possible d'effectuer les traitements dans la requête. De la même manière, évitez les requêtes dans une boucle PHP.

Optimiser les requêtes

99% des problèmes de performance sont causés par la base de données. La commande EXPLAIN de MySQL(tutoriel ici) permet de visualiser le plan d'exécution des requêtes, vous pourrez ainsi repérer les points bloquants. Des outils comme Query Profiler vous permettront également d'optimiser vos requêtes et votre schéma.

Utiliser le type de donnée adapté

Nous sommes souvent tenté de stocker des données sérialisées dans un champ de type texte. Ceci est très pratique mais peut s'avérer catastrophique en cas de forte volumétrie. Cette solution est donc à manipuler avec des pincettes, il est préférable d'utiliser au maximum les types de champs proposés par MySQL.

Eviter le "SELECT *"

Souvent, seuls certains champs sont nécessaires, il est donc inutile de tous les récupérer. Vous devez donc, spécifier les champs à récupérer un par un même si vous les voulez tous. En effet, si par la suite de nouveaux champs sont ajoutés à la table, le "*" les remontera alors qu'ils n'étaient pas nécessaires dans cette requête.

Manipuler les index raisonnablement

La règle de base pour positionner des index sur des tables est la suivante : toutes les colonnes aparaissant dans la clause WHERE de vos requêtes doivent avoir un index. On peut donc être tenté d'en positionner sur toutes les colonnes… surement pas ! En enffet, les index sont recalculés lors des opérations INSERT et UPDATE, ceci provoquerait des problèmes de performance.

Sauvegarder

Assurer vous de mettre en place des backups de la base. Vous pouvez également mettre en place un système de réplication master / slave.
Rappel : mysqldump permet d'effectuer des sauvegardes en ligne de commande.

Si vous avez des remarques ou des compléments à apporter, n'hésitez pas à commenter cet article.

 

 

Présentation

RedBean est un ORM (object-relational mapping) PHP. Il permet, comme tout ORM, de convertir les données relationnelles en objets et vice-versa. Il existe pléthore d'outils de ce style, nous pouvons citer par exemple Doctrine (un des plus connus, notamment utilisé avec Smfony), POG (PHP Object Generator) et Propel

Le principe de fonctionnement est le suivant :

ORM

L'ORM est capable de générer des objets (manipulables en PHP) à partir du schéma de la base de données. Les objets ainsi créés disposent d'attributs (champs de la base) et de méthodes (CRUD). Ce type d'outil permet d'interagir rapidement et facilement avec la base de données. Redbean possède un gros avantage : il est capable de créer le schéma directement depuis le code PHP, nous aborderons cet aspect dans ce tutoriel.

Un peu de pratique

Tout d'abord il faut importer redbean dans votre projet. Téléchargez les sources sur le site officiel de Redbean et ajoutez le fichier (php ou phar en fonction des versions) à votre projet :

require 'rb.php';

Vous pouvez maintenant commencer à jouer avec Redbean ! Configurez la base de données (créée au préalable) :

 R::setup('mysql:host=localhost;dbname=redbean_test','user','pwd');

Pour ce petit tutoriel nous allons créer une application permettant de gérer des utilisateurs et des notes. Le but étant ici de manipuler Redbean, aucune interface visuelle ne sera développée, nous nous concentrerons simplement sur quelques extraits de code PHP.

Comme dit précédement, avec redbean, nous n'avons pas besoin de créer les tables directement dans la base de données. Ainsi, le code suivant va nous permettre de créer un utilisateur et donc, la table associée :

$utilisateur = R::dispense('utilisateur');
$utilisateur->nom = 'Bosse';
$utilisateur->prenom = 'Hugo';
$idUser = R::store( $utilisateur )

Quelques explications :

  • La méthode "dispense" permet de créer un nouveau "bean", autrement dit un nouvel objet
  • La méthode "store" permet d'enregistrer le "bean"

Une fois le code précédent exécuté, consultez votre schéma de base de données, et là, surprise (ou pas, si vous avez suivi ^^)  :

database

Créons maintenant une note à l'aide du code suivant :

$note = R::dispense('note');
$note->title = 'Titre de la note';
$note->content = "<p>Lorem ipsum</p>";
$id = R::store( $note );

Nous disposons à présent de deux objets : un utilisateur et une note. Nous allons donc voir comment lier ces deux objets via une relation de type "one-to-many" :

$utilisateur = R::load('utilisateur', 1);
$note = R::load('note', 1);
$utilisateur->ownNoteList[] = $note;
R::store( $utilisateur );

Quelques explications :

  • La méthode "load" permet de charger les objets
  • L'attribut "ownNoteList[]" permet de lier la note à l'utilisateur 
  • La méthode "store" permet de mettre à jour les enregistrements

Voici ce que l'on obtient au niveau de la table "note" : 

note

On remarque qu'un nouveau champ permettant de stocker l'identifiant de l'utilisateur est apparu dans la table (relation de type one-to-many). Le mot clé "own" (ownNoteList) est obligatoire et permet d'illustrer la notion de possession (relation). Vous trouverez plus d'informations sur les relations dans la documentation officielle.

Une fois votre développement terminé, il est nécessaire de "bloquer" la mise à jour du schéma grâce à la méthode suivante :

R::freeze( TRUE );

Cette petite introduction à Redbean est terminée. Pour conclure, je dirai qu'il s'agit d'un outil simple à manipuler. Il peut être utile notamment pour mettre en place un prototype car il n'est pas nécessaire de gérer le schéma de la base de données. En revanche, dans le cadre d'une application destinée à la mise en production, il est indispensable de faire une passe sur le schéma afin de l'optimiser (index, clés…).

freegeoip.net est une API REST publique permettant de géolocaliser une adresse IP (ou un nom de domaine). L'API est limitée à 10000 appels par heures (ce qui semble suffisant), cependant, si vous souhaitez outrepasser cette limite, vous pouvez héberger vous-même ce service puisque freegeoip est open source. Vous trouverez les sources sur GitHub.

S'agissant d'un webservice REST, l'utilisation est très simple, il vous suffti d'appeller l'URL suivante :

	freegeoip.net/{format}/{ip_ou_nom_de_domaine}

Les formats supportés sont: JSON, CSV, et XML.

Voici un petit snippet permettant d'appeler ce service en CURL:

    //test sur une IP de google
    $api = 'http://freegeoip.net/json/173.194.67.94';
    
    $curl = curl_init();
    curl_setopt($curl, CURLOPT_URL, $api);
    curl_setopt($curl, CURLOPT_HEADER, false);
    curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($curl, CURLOPT_BINARYTRANSFER, true);
    curl_setopt($curl, CURLOPT_CONNECTTIMEOUT, 5);
    $data = curl_exec($curl);
    curl_close($curl);

Voici la chaine JSON récupérée :

{"ip":"173.194.67.94","country_code":"US","country_name":"United States","region_code":"CA","region_name":"California","city":"Mountain View","zipcode":"94043","latitude":37.4192,"longitude":-122.0574,"metro_code":"807","areacode":"650"}

Vous n'avez plus qu'à modifier le code ci-dessus pour l'intégrer dans une fonction et voilà, le tour est joué ! En retournant "json_decode($data)" vous obtiendrez un objet avec les attributs suivants : ip, country_code, country_name, region_code, region_name, city, zipcode, latitude, longitude, metro_code, area_code.

Ce petit service va vous permettre, par exemple, de personnaliser votre site web en fonction de la localisation de vos visiteurs (langue par défaut, indicatif téléphonique, affichage d'un drapeau etc.).

Présentation

Apache est un des permiers serveurs web à avoir vu le jour, il est aujourd'hui utilisé par environ 50% des sites (source Netcraft) et a largement fait ses preuves. Mais aujourd'hui le World Wild Web a explosé, et il n'est pas rare qu'un site doive gérer plus de 10000 utilisateurs simultanément, il s'agit de ce que l'on appelle le problème "C10k" (C plus client, 10k pour 10000). L'utilisation des processus faite par Apache est très gourmande, c'est pourquoi de nouvelles alternatives ont vu le jour. Nginx est l'une d'entre elles.

logo nginx

Basé sur la programation évènementielle asynchrone, Nginx minimise le nombre d'appels systèmes, en particulier, tout ce qui est lié à la mémoire. Tout comme Apache, Nginx est modulaire et dispose d'un grand nombre de fonctionnalités : authentification HTTP, compression Gzip, proxying, FastCGI, url-rewriting, localisation GeoIP… (voir la liste des modules).

​Installation et configuration 

Une commande classique fera l'affaire : "apt-get install nginx"
Cet artcile n'étant pas un tutoriel, mais plutôt une présentation, je vous laisse vous référer à la documentation officielle (RTFM  :p) pour la configuration.

Fonctionnement avec PHP

Nginx fonctionne avec le mode FPM de PHP (entretien en permanence un certain nombre de process).
Vous pourez l'installer à l'aide de la commande : apt-get install php5-fpm
Voici le lien vers différents exemples de configuration : http://wiki.nginx.org/Configuration

Conclusion

Ces dernières années, Nginx tend à s'imposer de plus en plus sur le marché. Voici, la répartition globale des serveurs web entre 1995 et 2013 (source Netcraft) :

En plus d'être un serveur web, Nginx peut également être configuré comme reverse proxy pour gérer le cache statique et également répartir la charge sur différents frontaux (load balancing). Contrairement à Varnish notamment, Nginx gère le SSL.

Si vous n'avez encore jamais eu l'occasion de le tester, il est grand temps de vous y mettre ! De simples tests de performances avec Apache Benchmark (ab) vous permettront de faire une rapide comparaison entre Nginx et Apache.

Aujourd'hui je vais vous présenter un framework PHP permetant de créer une API REST, il s'agit de Slim Framework. Je l'ai utilisé dans le cadre d'un projet perso, peut-être un jour disponible sur mon site… Il s'agit un outil très simple à mettre en place et à prendre en main, notamment grâce à sa documentation claire et complète.

Commençons par le début : que signifie REST ? "Representational State Transfer" est un type d’architecture permettant de mettre en place des webservices, il repose sur le protocole HTTP. Le principe est simple, le programmeur manipule directement les méthodes POST, PUT, GET et DELETE pour effectuer les actions de CRUD (Create, Read, Update, Delete):

  • création : POST
  • modification : PUT
  • lecture : GET
  • suppresssion : DELETE

Revenons à notre mouton "Slim", le snippet présent sur la page d'accueil du site donne le ton, ces quelques lignes de code suffisent pour créer un web service :

<?php
$app = new \Slim\Slim(); //initialisation de l'application
$app->get('/hello/:name', function ($name) { //route accessible via l'URL "http://nom_de_domaine_api/hello/toto"
    echo "Hello, $name"; // renvoie "Hello toto"
});
$app->run(); //lance l'application

Vous trouverez ci-dessous la liste des principales fonctionnalités :

  • encryption AES-256
  • authentification HTTP
  • gestion d'erreurs
  • mode debbug
  • cache
  • PDO
  • templating (Twig, Smarty)
  • sessions (cookies)
  • middleware

Si vous avez à mettre en place une API REST, je vous conseil de jeter un oeil à Slim. De mon point de vue, voici les principaux avantages de ce framework :

  • facile à prendre en main
  • léger
  • performant 

J'espère que cet article vous aura permis de découvrir un nouvel outil. N'hésitez pas à laisser un commentaire si vous avez eu l'occasion de travailler avec, donnez-moi votre avis.