Construire une API Pokémon en PHP : guide du débutant

Dans ce guide, nous passerons en revue les étapes pour créer un projet PHP de base qui utilise l'API Pokémon avec le framework Flight et des packages supplémentaires comme Zebra_cURL et Latte. Nous explorerons la configuration du projet, l'ajout d'itinéraires et le rendu des vues.

tl;dr : Il n'est pas difficile de créer un projet simple basé sur une API dans Flight. Consultez le code utilisé dans ce guide.

Étape 1 : Configuration de l'environnement

Tout d'abord, nous devons créer un nouveau dossier de projet. Ouvrez votre terminal, accédez à l'emplacement souhaité et exécutez les commandes suivantes pour créer un nouveau répertoire et entrez-le.

mkdir flight-pokeapi
cd flight-pokeapi

Étape 2 : Installation de Composer

Avant de plonger dans le code, nous devons nous assurer que Composer est installé. Composer est le gestionnaire de dépendances pour PHP, et il nous aidera à inclure les bibliothèques nécessaires.

Si Composer n'est pas installé, vous pouvez l'installer en utilisant :

php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');"
php composer-setup.php
php -r "unlink('composer-setup.php');"

Maintenant que Composer est installé dans un fichier actuel appelé ./composer.phar, gérons nos dépendances.

Étape 3 : Installation des dépendances

Pour gérer les packages requis, il suffit de les ajouter avec composer.

./composer.phar require flightphp/core stefangabos/zebra_curl latte/latte

Cela installera :

• Flight PHP : Un framework PHP léger.
• Zebra_cURL : un wrapper cURL pour gérer les requêtes HTTP.
• Latte : un moteur de création de modèles pour le rendu des vues.

Étape 4 : Configuration de index.php

Ensuite, créons le point d’entrée de notre application : public/index.php. Ce fichier configurera notre application, configurera les itinéraires et gérera le rendu des vues.

Créez le répertoire public et le fichier index.php :

mkdir public
touch public/index.php

Ajoutez maintenant le contenu suivant à index.php :

<?php use flight\net\Router;
use Latte\Engine;

require __DIR__ . '/../vendor/autoload.php'; // Autoload the installed packages

// Setup Latte for view rendering
$Latte = new Engine;
$Latte->setTempDirectory(__DIR__ . '/../temp');
Flight::map('render', function(string $template_path, array $data = []) use ($Latte) {
  $Latte->render(__DIR__ . '/../views/' . $template_path, $data);
});

// Setup Zebra_cURL for handling HTTP requests
$Curl = new Zebra_cURL();
$Curl->cache(__DIR__ . '/../temp');
Flight::map('curl', function() use ($Curl) { 
    return $Curl; 
});

// Define a simple route
Flight::route('/', function() {
  echo 'hello world!';
});

Flight::start();

Dans ce fichier :

• Nous chargeons le chargeur automatique de Composer.
• Configurez Latte pour le rendu des vues.
• Mappez une méthode de rendu personnalisée qui utilise Latte pour restituer les modèles à partir du dossier /views.
• Configurez Zebra_cURL pour gérer les requêtes API et mappez-le pour utiliser Flight::curl() lorsque nous voulons l'invoquer.
• Définissez un itinéraire simple pour la page d'accueil (/) qui renvoie simplement "hello world!"

Si vous souhaitez tester cette configuration, vous pouvez démarrer un serveur PHP depuis le répertoire public :

php -S localhost:8000 -t public/

Maintenant, visitez http://localhost:8000/ dans votre navigateur et vous devriez voir « hello world ! ». Cool hein ?

Étape 5 : Ajouter des itinéraires

Maintenant que nous avons configuré un itinéraire de base, ajoutons un itinéraire plus complexe qui utilise l'API Pokémon. Mettez à jour public/index.php pour inclure le code suivant :

Flight::group('/pokemon', function(Router $router) {
    // Route to list all Pokémon types
    $router->get('/', function() {
        $types_response = json_decode(Flight::curl()->scrap('https://pokeapi.co/api/v2/type/', true));
        $results = [];
        while ($types_response->next) {
            $results = array_merge($results, $types_response->results);
            $types_response = json_decode(Flight::curl()->scrap($types_response->next, true));
        }
        $results = array_merge($results, $types_response->results);
        Flight::render('home.latte', [ 'types' => $results ]);
    });
});

• Nous avons créé un groupe de routes /pokemon. Un groupe de routes « entoure » les routes et nous permet de définir des fonctionnalités communes à toutes les routes du groupe.
• La route /pokemon répertorie tous les types de Pokémon disponibles en les récupérant depuis l'API Pokémon à l'aide de Zebra_cURL.
• Cela ne fonctionnera pas encore car nous devons ajouter la vue home.latte pour afficher les types de Pokémon.

Étape 6 : Rendu des vues avec Latte

Maintenant que nous récupérons les données, configurons des vues pour les afficher. Créez le répertoire des vues et ajoutez un fichier de modèle Latte pour afficher les types de Pokémon.

mkdir views
touch views/home.latte

Ajoutez le code suivant à vues/home.latte :

<p>Welcome to the Pokemon World!</p>

<p>Types of Pokemon</p>

{foreach $types as $type}
• {$type->name|firstUpper}
{/foreach}

Dans ce fichier :

• Nous parcourons le tableau $types transmis depuis notre itinéraire et affichons le nom de chaque type de Pokémon.

Maintenant, visiter /pokemon affichera une liste de tous les types de Pokémon !

Étape 7 : Regroupement et ajout d'itinéraires supplémentaires

Étendons nos itinéraires Pokémon pour obtenir plus de détails sur des types spécifiques et des Pokémon individuels. Ajoutez les itinéraires suivants à votre groupe /pokemon :

// Route to fetch a specific Pokémon type and list all associated Pokémon
$router->get('/type/@type', function(string $type) {
    $Curl = Flight::curl();
    $type_response = json_decode($Curl->scrap('https://pokeapi.co/api/v2/type/' . $type, true));
    $pokemon_urls = [];
    foreach($type_response->pokemon as $pokemon_data) {
        $pokemon_urls[] = $pokemon_data->pokemon->url;
    }
    $pokemon_data = [];

    // The little & here is important to pass the variable by reference.
    // In other words it allows us to modify the variable inside the closure.
    $Curl->get($pokemon_urls, function(stdClass $result) use (&$pokemon_data) {
        $pokemon_data[] = json_decode($result->body);
    });

    Flight::render('type.latte', [ 
        'type' => $type_response->name,
        'pokemons' => $pokemon_data
    ]);
});

Dans cet itinéraire, nous :

• Récupérez les détails d'un type de Pokémon spécifique, y compris tous les Pokémon associés.
• Envoyez plusieurs requêtes API pour récupérer les détails de chaque Pokémon.
• Rendez les données à l'aide d'un modèle (type.latte).

Ensuite, créez la vue type.latte :

touch views/type.latte

Ajoutez le contenu suivant à type.latte :

<h1 id="type-firstUpper">{$type|firstUpper}</h1>

{foreach $pokemons as $pokemon}
• {$pokemon->name|firstUpper}
{/foreach}

Ce modèle affiche le nom de chaque Pokémon associé à un type spécifique.

Étape 8 : Est-ce que ça marche ?

À ce stade, vous disposez d'un consommateur d'API Pokémon de base configuré à l'aide de Flight PHP, Zebra_cURL pour les requêtes API et Latte pour le rendu des vues. Vous pouvez étendre davantage ce projet en ajoutant plus d'itinéraires et en affinant les modèles.

Pour visualiser votre projet, démarrez le serveur PHP depuis le répertoire public :

php -S localhost:8000 -t public/

Maintenant, visitez http://localhost:8000/pokemon dans votre navigateur et vous devriez voir une liste des types de Pokémon.

Dépannage

Si vous avez besoin d'aide ou rencontrez des problèmes, vous pouvez consulter le code complet dans Github pour voir où vous avez pu faire un faux pas.

J'espère que vous avez apprécié ce petit tutoriel. Si vous avez des questions ou avez besoin d'aide, n'hésitez pas à les poser dans les commentaires ci-dessous. Bon codage !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!