Share
Dans cet article, nous allons apprendre à créer un moteur de blog de fichiers à plat en PHP en utilisant le framework Slim. Si vous ne comprenez pas le jargon, ne vous inquiétez pas. Nous allons simplement créer une application de blogging spartiate, qui utilise des fichiers texte plutôt qu'une base de données pour stocker des données..
Si vous êtes débutant, ne vous inquiétez pas! Nous allons commencer par les bases de l'utilisation de Slim. Commençons après le saut!
Slim est un framework PHP léger reposant pour la création de sites Web simples. Il est inspiré de Sinatra, un framework écrit en Ruby. Slim est livré avec quelques composants minimaux, comme
Demande de réponseetVuequi sont les seuls composants requis dans notre moteur de blog à plat.
Pour commencer, configurons une application hello world. Avant cela, vous devez télécharger le framework Slim sur votre système. Nous n'allons pas beaucoup parler de Slim car il a déjà été couvert ici chez Nettuts +. Vous devriez idéalement avoir les fichiers suivants dans votre dossier:
Accentsconagua
Svelte/ - Cadre minceIndex.php - Le fichier d'index.htaccess - Pour la réécriture d'URL Maintenant ouvrir index.php, où vous verrez un tas de HTML dans la section suivante. J'ai tout enlevé et remplacé par "Hello world". Vous index.php devrait, espérons-le, ressembler à ceci maintenant.
nécessite 'Slim / Slim.php'; $ app = new Slim (); $ app-> get ('/', function () echo "Bonjour le monde
";); $ app-> run (); J'ai créé un Virtualhost sur ma machine, qui correspond à l'URL indiquée dans la capture d'écran. Ajustez l'URL en fonction de l'emplacement de Slim dans votre machine.
Accédez à l'URL et vous verrez une page d'accueil contenant le texte "Hello world".
obtenir() est une méthode Slim, qui prend un itinéraire comme premier argument et une fonction de rappel correspondante comme dernier. Autre que obtenir, nous pouvons avoir des itinéraires pour le POST, PUT et EFFACER les verbes aussi. Comme Slim supporte PHP 5.3, la fonction de rappel peut être écrite et est écrite comme une fonction anonyme..
L'étape suivante consiste à rendre un fichier PHP. Avant de continuer, créez un répertoire appelé des modèles pour stocker tous nos fichiers modèles. Tous les fichiers HTML ou modèles statiques que nous créons seront placés dans ce dossier. Slim nous permet de spécifier le chemin d'accès à nos fichiers modèles dans sa configuration. Nous pouvons ajouter une configuration comme indiqué ci-dessous.
$ app-> config (array ('templates.path' => './templates')); Créons une page à propos de notre blog. Créez un fichier PHP appelé about.php et placez-le dans le des modèles dossier. Ajoutez-y le code suivant:
Un moteur de blog slim À propos de la page
Cette page est un exemple de route statique, rendant un fichier php.
Pour que Slim puisse traiter une demande, nous devons définir un Route qui peut mapper à cette URL. Dans notre première étape, nous avons ajouté un itinéraire à la indice ou '/ ". Ajoutons maintenant un autre itinéraire pour notre page sur.
$ app-> get ('/ about', function () use ($ app) $ app-> render ('about.php');); Si vous chargez http: //slim.local/about espérons que dans votre navigateur, il devrait afficher quelque chose comme ceci:
Nous avons ajouté un itinéraire à la page à propos, qui affichera about.php situé à ./ modèles (se souvenir du template.path variable de configuration?). Avez-vous remarqué que nous avons utilisé utiliser ($ app) à l'intérieur de obtenir méthode? Eh bien, c'est juste une façon d'utiliser une variable à l'intérieur d'une fonction anonyme qui est en dehors de sa portée.
Nous pouvons maintenant afficher une page de modèle pour un itinéraire. Il est temps de penser à l'affichage de valeurs dynamiques dans le modèle, car nous ne pouvons pas toujours restituer et servir des fichiers statiques. Nous pouvons attribuer des valeurs à rendre dans un modèle à partir du rendre() méthode. Il devrait être passé en tant que deuxième paramètre sous forme de tableau associatif. Changeons le code ci-dessus pour ressembler à ceci:
$ app-> get ('/ about', function () use ($ app) $ data = array ('heading' => 'About page', 'message' => 'Cette page est un exemple de route statique, rendu un fichier php. '); $ app-> render (' about.php ', $ data);); Et changez un peu le corps du template.
Vous remarquerez que vous pouvez voir la même page si vous rechargez l'URL précédente. Les variables utilisées dans le fichier modèle sont les clés correspondantes du tableau associatif..
Jusqu'ici, nous avons joué avec certains itinéraires statiques, '/' et '/ about'. Nous allons maintenant créer un itinéraire dynamique, c’est-à-dire un itinéraire pouvant répondre à différentes URL..
$ app-> get ('/: param1 /: param2', fonction ($ param1, $ param2) utilisez ($ app) echo $ param1. '-'. $ param2;); Slim appelle toujours le premier itinéraire correspondant à la requête HTTP actuelle. Cela signifie que tous les itinéraires statiques doivent être définis avant les itinéraires dynamiques.
Si vous chargez http: //slim.local/first-param/second-param dans votre navigateur, il affichera first-param - second-param.
Le chemin d'une variable doit commencer par un ':'. Slim transmettra la valeur de cette variable en tant qu'argument à notre fonction de rappel, afin que nous puissions l'analyser et effectuer une opération appropriée. Slim attend exactement deux paramètres pour la route ci-dessus puisque les deux variables de route sont obligatoires. Si ce n'est pas présent, Slim affichera une erreur 404. Nous pouvons rendre un paramètre d'URL facultatif, comme indiqué à l'étape suivante..
Pour rendre un paramètre de route facultatif, réécrivez le code ci-dessus comme indiqué ci-dessous:
$ app-> get ('/: param1 (/: param2 (/: param3))', function () use ($ app) $ args = func_get_args (); foreach ($ args en tant que $ arg) echo $ arg . '-';); Avec cela, les deuxième et troisième paramètres sont facultatifs. Nous pouvons utiliser le func_get_args ()méthode pour obtenir tous les arguments passés dans la fonction de rappel.
Bon, il est temps d'entrer dans une affaire sérieuse. Nous disposons maintenant de toutes les informations requises pour créer un moteur de blog à fichier plat. Rassemblons les connaissances susmentionnées pour les créer.
Nous devons créer un système de fichiers avant de rassembler tous ces composants. Voici un système de fichiers simple pour notre application.
Il s’agit d’un système de fichiers minimaliste ne contenant que les fichiers / dossiers requis. Tous les articles seront conservés dans le des articles dossier. le les atouts dossier hébergera nos fichiers CSS et JavaScript ainsi que des images. Svelte contiendra les fichiers de framework et template.
Si vous vous sentez un peu perdu, voici un aperçu de la structure de notre application..
json_decode () une fonction. Le contenu et les métadonnées seront séparés par une ligne vide. Ajoutons un itinéraire qui chargera un article à partir du dossier articles basé sur l'URL.
// ajout de l'emplacement de l'article dans la configuration $ app-> config (array ('templates.path' => './templates', 'article.path' => './articles' // emplacement des articles)); // '/ post-url' chargera le fichier post-url.txt. $ app-> get ('/: article', fonction ($ article) use ($ app) $ path = $ app-> config ('article.path'); // ouvre un fichier texte et le lit. $ handle = fopen ($ path. '/'. $ article. '.txt', 'r'); $ content = stream_get_contents ($ handle); // divise le contenu pour obtenir les métadonnées $ content = explode ("\ n \ n" $ meta = json_decode ($ rawMeta, true); $ content = implode ("\ n \ n", $ content); $ contentMeta = array_shift ($ content); // métadonnées // json. ); $ article = array ('meta' => $ meta, 'content' => $ content); $ app-> render ('article.php', $ article);); Nous avons ajouté une route dynamique avec un paramètre de route unique. La fonction de rappel recevra la valeur de ce paramètre, qui devrait être un nom de fichier sans son extension. Ensuite, nous extrayons la valeur de la article.path variable de configuration, où nous gardons nos articles.
Dans les deux lignes suivantes, nous lisons ce fichier et stockons son contenu dans une variable, $ contenu . Comme je l'ai mentionné dans le paragraphe précédent, un article comportera des métadonnées et un contenu réel qui seront séparés par une seule ligne ("\ n \ n"). Souvent, il peut y avoir beaucoup d'autres lignes vides dans le contenu d'un article, ce qui va probablement casser la méthode actuelle. Pour éviter cela, nous utiliserons le premier élément pour obtenir des métadonnées et joindrons le reste du tableau en utilisant la même ligne vide. Les métadonnées étant au format JSON, nous devons les décoder d’ici et les stocker dans le fichier. $ meta tableau.
Créez un fichier modèle pour rendre un article et placez-le dans le modèle dossier.
//article.php echo ''. $ meta ['title']. '
'; echo $ content;
Créons notre premier article de blog maintenant. Créer un nouveau fichier nommé premier-article.txt, placez-le dans le des articles dossier et ajoutez le contenu comme indiqué ci-dessous. Assurez-vous que les métadonnées et le contenu sont séparés par une ligne vide..
//first-article.txt "title": "Ceci est mon premier article", "date": "15/02/2012", "slug": "premier article", "author": "nom de l'auteur" Gâteau aux fruits jelly-o halvah bonbon à la guimauve. Croissant, cannes de sucre, gâteau au chocolat, muffin, gelée, haricots, réglisse…
Excellent! Vous pouvez commencer à poster des articles maintenant. Mais attendez! Nous n'avons pas encore de page de liste. Nous devons répertorier tous les articles disponibles dans notre système, avec son titre et une petite description. Pour ce faire, nous devrons analyser le dossier articles afin de trouver tous les articles et les ajouter à un tableau les lisant les uns après les autres..
$ app-> get ('/', function () utiliser ($ app) $ path = $ app-> config ('article.path'); $ dir = new DirectoryIterator ($ path); $ articles = array ( ); foreach ($ dir en tant que $ fichier) if ($ fichier-> isFile ()) $ handle = fopen ($ chemin. '/'. $ fichier-> getFilename (), 'r'); $ content = stream_get_contents ($ handle); $ content = exploser ("\ n \ n", $ content); $ rawMeta = array_shift ($ content); $ meta = json_decode ($ rawMeta, true); $ content = implode ("\ n \ n ", $ content); $ articles [$ file-> getFilename ()] = array ('meta' => $ meta, 'content' => $ content); $ app-> render ('index. php ', array (' articles '=> $ articles));); Ici, nous avons ajouté un itinéraire à la page d'accueil. Nous utilisons PHP intégré Directoryiterator classe à parcourir en boucle chaque fichier du répertoire. Chaque article est ajouté à la $ articles tableau. À partir du fichier de modèle (index.php), nous pouvons parcourir ces articles comme indiqué ci-dessous.
foreach ($ articles en tant que $ article) echo "". $ article ['meta'] ['titre']."
"; echo substr (strip_tags ($ article ['content']), 0,200). '… En lire plus >>';
Notre page d'accueil est prête maintenant. Il listera tous les articles de notre blog, avec le titre correspondant et une partie du contenu..
Ensuite, nous allons créer une page 'archives'. Puisque nous nous attendons à ce que la page d'archives ait des filtres basés sur l'année, le mois et la date, nous allons ajouter un itinéraire avec des paramètres facultatifs. La page des archives supportera les URL suivantes.
Pour ce faire, nous allons charger tous les articles et les filtrer en fonction des arguments passés à la fonction de rappel. J'ai tout déplacé dans une classe afin que nous puissions commencer à réutiliser notre code. Un itinéraire prenant en charge les URL ci-dessus se présentera comme suit:
// assigne $ this à une autre variable car elle n'est pas supportée à l'intérieur de la fermeture $ blog = new Blog (); $ slim-> get ('/ archives (/: yyyy (/: mm (/: jj)))', function () use ($ blog, $ slim) ); Notez que dans cette route, l'année, le mois et la date sont des paramètres facultatifs.. /les archives est la seule partie requise de l'URL. Ensuite, nous devons implémenter cette route qui répondra en fonction des paramètres facultatifs.
$ args = func_get_args (); // charge tous les articles $ articles = $ blog-> loadArticles (); $ archives = array (); // contrôle le nombre ($ args) des paramètres de route facultatifs if (nombre ($ args)> 0) switch (nombre ($ args)) cas 1: // seule l'année est présente $ format = 'Y'; $ date = $ dateFormat ($ args, $ format); Pause; cas 2: // l'année et le mois sont présents $ format = 'Y-m'; $ date = $ dateFormat ($ args, $ format); Pause; cas 3: // l'année, le mois et la date sont présents $ format = 'Y-m-d'; $ date = $ dateFormat ($ args, $ format); Pause; // filtre les articles pour chaque ($ articles en tant que $ article) if ($ dateFormat ($ article ['méta'] ['date'], $ format) == $ date) $ archives [] = $ article; else $ archives = $ articles; // render archives $ slim-> render ('archives.php', array ('archives' => $ archives)); À l'intérieur de commutateur déclaration, nous créons la date à filtrer en utilisant les arguments passés. Cette date est comparée à la date de chaque article et s’ils correspondent, elle est ajoutée au $ archives tableau. $ dateFormat () est une fonction anonyme à l'intérieur de la route pour formater les dates.
$ dateFormat = function ($ args, $ format) $ temp_date = is_array ($ args)? imploser ('-', $ args): $ args; $ date = new DateTime ($ temp_date); return $ date-> format ($ format); ; Nous pouvons écrire des conditions pour un itinéraire auquel les arguments doivent satisfaire, afin de valider l'année, le mois et la date passés à l'itinéraire..
$ slim-> get ('/ archives (/: yyyy (/: mm (/: jj)))', function () utilise $ blog ) -> conditions (array ('yyyy' => '(19 | 20) \ d \ d ',' mm '=>' (0 [1-9] | 1 [0-2]) ',' dd '=>' (0 [1-9] | [1-2] [0-9] | 3 [0-1]) ')); Ici, l'année devrait commencer par 19 ou 20, suivie de deux chiffres quelconques. Le mois doit être compris entre 1 et 12 et la date doit être comprise entre 01 et 31.
Voici la page d'archives que j'ai créée avec le code ci-dessus. Si vous avez remarqué que j'ai utilisé Twitter Bootstrap pour appliquer certains styles de base, vous obtenez un cookie supplémentaire.!
Nous possédons maintenant un modèle fonctionnel de moteur de blog à fichier plat. La prochaine chose que nous devons faire est d’organiser l’application pour éviter la duplication de code et d’ajouter des fonctionnalités telles que les commentaires, etc. Passons ce code de index.php dans une classe séparée pour une meilleure organisation.
Jusqu'à présent, nous avons utilisé le Vue classe du framework Slim. Nous pouvons créer une classe de vue personnalisée qui s'étendra Slim_View pour l'ajout de fonctionnalités supplémentaires telles que la définition d'une mise en page de base, de paramètres globaux, etc. Si vous préférez écrire des articles dans Markdown, vous pouvez également inclure un analyseur syntaxique de Markdown..
Nous devrions également chercher à améliorer l'esthétique de l'application. Je préfère utiliser Twitter bootstrap car il est vraiment très facile à utiliser et à personnaliser. Je ne pense pas que ce soit une bonne idée de creuser ces détails ici. Je les ai compilés dans une application simple appelée TextPress qui peut être téléchargée ici.
Presque tous les moteurs de blog à fichier plat préfèrent vivre dans le nuage. De plus, Git est probablement utilisé pour la publication d'articles. Avec notre moteur, vous pouvez créer des publications à l'aide d'un simple fichier texte et les publier à l'aide de la ligne de commande. Comme il n'y a pas de panneau d'administration à pirater, il est beaucoup plus sécurisé que presque tout autre système de gestion de contenu. Surtout, il est facile à héberger, car les services de plateforme, tels que PHP Fog, nous permettent d’héberger librement des applications dans le cloud..
Donc c'est à peu près tout. Faites-moi savoir si vous avez des questions dans les commentaires ci-dessous et merci beaucoup d'avoir lu!
