Share
In dit artikel zullen we leren hoe een platte blog-engine voor bestanden in PHP te maken met behulp van het Slim-framework. Als je het jargon niet begrijpt, maak je geen zorgen. We gaan gewoon een spartaanse blogtoepassing maken, die tekstbestanden gebruikt in plaats van een database om gegevens op te slaan.
Als je een beginner bent, wees niet bang! We zullen beginnen met de basis van het gebruik van Slim. Laten we aan de slag na de sprong!
Slim is een lichtgewicht RESTful PHP-framework voor het maken van eenvoudige websites. Het is geïnspireerd op Sinatra, een raamwerk geschreven in Ruby. Slanke schepen met enkele minimale componenten, zoals
Aanvraag antwoordenUitzichtwelke de enige vereiste componenten zijn in onze flat-file blog engine.
Laten we beginnen met het opzetten van een Hello World-toepassing. Vóór dat moet je het Slim-framework downloaden naar je systeem. We gaan niet veel over Slank bespreken, omdat het hier al is behandeld bij Nettuts +. U zou idealiter de volgende bestanden in uw map moeten hebben:
Accentsconagua
Slank/ - Slank kaderindex.php - Het indexbestand.htaccess - Voor URL-herschrijving Open nu index.php, waar je een hoop HTML ziet in de volgende sectie. Ik heb alles verwijderd en het vervangen door "Hallo wereld". U index.php zou er hopelijk nu zo uit moeten zien.
vereisen 'Slim / Slim.php'; $ app = nieuwe Slim (); $ app-> get ('/', function () echo "Hallo Wereld
";); $ app-> run (); Ik heb een Virtualhost gemaakt in mijn machine, de URL die wordt weergegeven in de schermafbeelding. Pas de URL aan op basis van de locatie van Slim in uw machine.
Navigeer naar de URL en je ziet een startpagina met daarin de tekst 'Hallo wereld'.
krijgen() is een Slim-methode, die een route als het eerste argument en een overeenkomstige callback-functie als de laatste zal nemen. Anders dan krijgen, we kunnen routes hebben voor de POST, PUT en DELETE werkwoorden ook. Aangezien Slim PHP 5.3 ondersteunt, kan de callback-functie worden geschreven als een anonieme functie.
De volgende stap is om een PHP-bestand te renderen. Maak voordat u verder gaat een map met de naam templates om al onze sjabloonbestanden op te slaan. Alle statische HTML- of sjabloonbestanden die we maken, worden in deze map geplaatst. Slim stelt ons in staat om het pad naar onze sjabloonbestanden in zijn configuratie op te geven. We kunnen een configuratie toevoegen zoals hieronder getoond.
$ app-> config (array ('templates.path' => './templates')); Laten we een pagina over ons blog maken. Maak een PHP-bestand met de naam about.php en plaats het in de templates map. Voeg de volgende code eraan toe:
Een slanke blog-engine Over de pagina
Deze pagina is een voorbeeld van een statische route, waarmee een php-bestand wordt weergegeven.
Om Slim een verzoek te laten verwerken, moeten we een overeenkomstige definiëren Route die kan toewijzen aan die URL. In onze eerste stap hebben we een route toegevoegd aan de inhoudsopgave of '/'. Laten we nu een andere route toevoegen voor onze pagina over.
$ app-> get ('/ about', function () gebruik ($ app) $ app-> render ('about.php');); Als je laadt http: //slim.local/about in uw browser zou dit hopelijk iets als dit moeten weergeven:
We hebben een route toegevoegd aan de pagina over, die wordt weergegeven about.php gevestigd in ./ templates (herinner de template.path config variabele?). Heb je gemerkt dat we het gebruikten gebruik ($ app) binnen in de krijgen methode? Nou, dit is slechts een manier om een variabele binnen een anonieme functie te gebruiken die buiten de scope valt.
Nu kunnen we een sjabloonpagina voor een route weergeven. Het is tijd om na te denken over het weergeven van enkele dynamische waarden in de sjabloon, omdat we mogelijk niet altijd statische bestanden renderen en presenteren. We kunnen waarden toewijzen die moeten worden weergegeven in een sjabloon van de render () methode. Het moet als de tweede parameter worden doorgegeven als een associatieve array. Laten we de bovenstaande code veranderen om er zo uit te zien:
$ app-> get ('/ about', function () gebruik ($ app) $ data = array ('heading' => 'Over pagina', 'message' => 'Deze pagina is een voorbeeld van een statische route, rendering van een php-bestand. '); $ app-> render (' about.php ', $ data);); En verander het lichaam van de sjabloon een beetje.
U zult merken dat u dezelfde pagina kunt zien als u de vorige URL opnieuw laadt. Variabelen die in het sjabloonbestand worden gebruikt, zijn de overeenkomstige sleutels in de associatieve array.
Tot nu toe hebben we gespeeld met een aantal statische routes, '/' en '/ about'. Nu gaan we een dynamische route maken, d.w.z. een route die op verschillende URL's kan reageren.
$ app-> get ('/: param1 /: param2', functie ($ param1, $ param2) gebruik ($ app) echo $ param1. '-'. $ param2;); Slim roept altijd de eerste route in die overeenkomt met het huidige HTTP-verzoek. Dit betekent dat alle statische routes moeten worden gedefinieerd vóór dynamische routes.
Als je laadt http: //slim.local/first-param/second-param in uw browser wordt weergegeven eerste parameter - tweede parameter.
De route van een variabele moet beginnen met een ':'. Slim geeft de waarde van deze variabele door als argument voor onze callback-functie, zodat we deze kunnen parseren en een geschikte bewerking kunnen uitvoeren. Slim verwacht precies twee parameters voor de bovenstaande route omdat de twee routevariabelen verplicht zijn. Als het niet aanwezig is, geeft Slim een 404-fout weer. We kunnen een URL-parameter optioneel maken, zoals getoond in de volgende stap.
Om een routeparameter optioneel te maken, herschrijft u de bovenstaande code zoals hieronder getoond:
$ app-> get ('/: param1 (/: param2 (/: param3))', function () gebruik ($ app) $ args = func_get_args (); foreach ($ args als $ arg) echo $ arg . - ';); Daarmee zijn de tweede en derde parameter optioneel. We kunnen de gebruiken func_get_args ()methode om alle argumenten te verkrijgen die worden doorgegeven aan de callback-functie.
Oké, het is tijd om een serieus bedrijf te beginnen. Nu hebben we alle benodigde informatie om een platte blog-engine te maken. Laten we de hierboven besproken kennis samenvoegen om het te creëren.
We moeten een bestandssysteem maken voordat we al deze verschillende componenten samenvoegen. Hier is een eenvoudig bestandssysteem voor onze applicatie.
Dit is een minimalistisch bestandssysteem met alleen de vereiste bestanden / mappen. Alle artikelen worden bewaard in de artikelen map. De middelen map bevat onze CSS- en JavaScript-bestanden en afbeeldingen. Slank bevat de framework- en sjabloonbestanden.
Als je je een beetje verloren voelt, is hier een kort overzicht van hoe onze applicatie is gestructureerd.
json_decode () functie. Inhoud en metadata worden gescheiden door een lege regel. Laten we een route toevoegen die een artikel uit de artikelenmap laadt op basis van de URL.
// plaats artikellocatie in configuratie $ app-> config (array ('templates.path' => './templates', 'article.path' => './articles' // locatie van artikelen)); // '/ post-url' laadt het bestand post-url.txt. $ app-> get ('/: artikel', functie ($ artikel) gebruik ($ app) $ path = $ app-> config ('article.path'); // open tekstbestand en lees het $ handle = fopen ($ path. '/'. $ article. '.txt', 'r'); $ content = stream_get_contents ($ handle); // deel de inhoud om metadata te krijgen $ content = explode ("\ n \ n" , $ inhoud); $ rawMeta = array_shift ($ content); // metadata is json-gecodeerd, dus decodeer het. $ meta = json_decode ($ rawMeta, true); $ content = implode ("\ n \ n", $ content ); $ article = array ('meta' => $ meta, 'content' => $ content); $ app-> render ('article.php', $ article);); We hebben een dynamische route toegevoegd met een enkele routeparameter. De callback-functie zal de waarde voor die parameter ontvangen, wat een bestandsnaam zonder extensie zou moeten zijn. Vervolgens extraheren we de waarde van de article.path configuratievariabele, waar we onze artikelen bewaren.
In de volgende twee regels lezen we dat bestand en slaan we de inhoud op in een variabele, $ inhoud . Zoals ik in de vorige alinea al heb vermeld, bevat een artikel metagegevens en daadwerkelijke inhoud die door één regel worden gescheiden ("\ n \ n"). Vaak zijn er veel andere lege regels in de inhoud van een artikel, die waarschijnlijk de huidige methode zullen doorbreken. Om dit te voorkomen, zullen we het eerste element gebruiken om metadata te krijgen en zullen we de rest van de array samenvoegen met dezelfde blanco regel. Omdat de metadata de JSON-indeling hebben, moeten we die hier decoderen en opslaan in de $ meta rangschikking.
Maak een sjabloonbestand om een artikel te renderen en plaats het in de sjabloon map.
//article.php echo ''. $ meta ['titel']. '
'; echo $ inhoud;
Laten we nu onze eerste blogpost maken. Maak een nieuw bestand met de naam eerste article.txt, plaats het in de artikelen map en voeg de inhoud toe zoals hieronder getoond. Zorg ervoor dat de metagegevens en inhoud gescheiden zijn door een lege regel.
//eerste-artikel.txt "titel": "Dit is mijn eerste artikel", "datum": "15/02/2012", "slug": "eerste-artikel", "auteur": "Naam auteur" Vruchtencake gelei-o halvah marshmallow bonbon. Croissant snoepriet chocoladecake muffin jelly beans zoethout ... (kopieer wat lippenum)
Uitstekend! U kunt nu beginnen met het posten van artikelen. Maar wacht! We hebben nog geen aanbiedingspagina. We moeten alle artikelen vermelden die beschikbaar zijn in ons systeem, met de titel en een kleine beschrijving. Om dit voor elkaar te krijgen, moeten we de artikelenmap ontleden om alle artikelen te vinden en ze aan een array toe te voegen, ze een voor een lezen.
$ app-> get ('/', functie () gebruik ($ app) $ path = $ app-> config ('article.path'); $ dir = nieuwe DirectoryIterator ($ path); $ articles = array ( ) foreach ($ dir als $ bestand) if ($ file-> isFile ()) $ handle = fopen ($ path. '/'. $ file-> getFilename (), 'r'); $ content = stream_get_contents ($ handle); $ content = explode ("\ n \ n", $ content); $ rawMeta = array_shift ($ content); $ meta = json_decode ($ rawMeta, true); $ content = implode ("\ n \ n ", $ inhoud); $ artikelen [$ file-> getFilename ()] = array ('meta' => $ meta, 'content' => $ content); $ app-> render ('index. php ', array (' articles '=> $ artikelen));); Hier hebben we een route naar de startpagina toegevoegd. We gebruiken ingebouwde PHP's DirectoryIterator klasse om door elk bestand in de map te bladeren. Elk artikel is toegevoegd aan de $ artikelen matrix. Van het sjabloonbestand (index.php), kunnen we deze artikelen doorlopen, zoals hieronder weergegeven.
foreach ($ artikelen als $ artikel) echo "". $ article ['meta'] ['title']."
"; echo substr (strip_tags ($ article ['content']), 0,200). '... Lees meer >>';
Onze startpagina is nu klaar. Het zal alle artikelen in onze blog vermelden, met de bijbehorende titel en een deel van de inhoud.
Vervolgens maken we een 'archieven'-pagina. Omdat we verwachten dat de archiefpagina filters heeft op basis van jaar, maand en datum, voegen we een route toe met optionele parameters. De archievenpagina zal de volgende URL's ondersteunen.
Om dit te bereiken, laden we alle artikelen en filteren ze op basis van de argumenten die aan de callback-functie zijn doorgegeven. Ik heb alles naar een klas verplaatst, zodat we onze code kunnen hergebruiken. Een route die bovenstaande URL's ondersteunt, ziet er ongeveer zo uit:
// wijs $ dit toe aan een andere variabele omdat het niet wordt ondersteund binnen de sluiting $ blog = new Blog (); $ slim-> get ('/ archives (/: yyyy (/: mm (/: dd)))', function () gebruik ($ blog, $ slim) ); Merk op dat op deze route het jaar, de maand en de datum optionele parameters zijn. / archief is het enige vereiste deel van de URL. Vervolgens moeten we deze route implementeren die zal reageren op basis van de optionele parameters.
$ args = func_get_args (); // laad alle artikelen $ articles = $ blog-> loadArticles (); $ archives = array (); // check count ($ args) voor optionele route params if (count ($ args)> 0) switch (count ($ args)) case 1: // alleen jaar is aanwezig $ format = 'Y'; $ date = $ dateFormat ($ args, $ format); breken; geval 2: // jaar en maand zijn aanwezig $ format = 'Y-m'; $ date = $ dateFormat ($ args, $ format); breken; geval 3: // jaar, maand en datum zijn aanwezig $ format = 'Y-m-d'; $ date = $ dateFormat ($ args, $ format); breken; // filter artikelen voor elk ($ artikelen als $ artikel) if ($ dateFormat ($ article ['meta'] ['date'], $ format) == $ date) $ archives [] = $ article; else $ archives = $ articles; // render archieven $ slim-> render ('archives.php', array ('archives' => $ archives)); Binnen in de schakelaar verklaring, maken we de datum die moet worden gefilterd met behulp van de doorgegeven argumenten. Deze datum wordt vergeleken met de datum van elk artikel en als ze overeenkomen, wordt deze toegevoegd aan de $ archieven rangschikking. $ DateFormat () is een anonieme functie binnen de route om datums te formatteren.
$ dateFormat = function ($ args, $ format) $ temp_date = is_array ($ args)? imploderen ('-', $ args): $ args; $ date = new DateTime ($ temp_date); return $ datum-> formaat ($ formaat); ; We kunnen voorwaarden voor een route schrijven waaraan de argumenten moeten voldoen om het jaar, de maand en de datum te valideren die aan de route zijn doorgegeven.
$ slim-> get ('/ archives (/: yyyy (/: mm (/: dd)))', function () gebruik $ blog ) -> voorwaarden (array ('yyyy' => '(19 | 20) \ d \ d ',' mm '=>' (0 [1-9] | 1 [0-2]) ',' dd '=>' (0 [1-9] | [1-2] [0-9] | 3 [0-1]) ')); Hier moet het jaar beginnen met 19 of 20 gevolgd door twee cijfers. De maand moet liggen tussen 1 en 12 en de datum moet tussen 01 en 31 liggen.
Hier is de archievenpagina die ik heb gemaakt met de bovenstaande code. Als je hebt gemerkt dat ik Twitter Bootstrap heb gebruikt voor het toepassen van een aantal basisstijlen, krijg je een extra cookie!
Welnu, we beschikken nu over een werkmodel van een platte blog-engine. Het volgende dat we moeten doen, is de toepassing organiseren om codeduplicatie te voorkomen en functies zoals opmerkingen toevoegen, enzovoort. Laten we deze code verplaatsen index.php naar een aparte klas voor een betere organisatie.
Tot nu toe hebben we de Uitzicht klasse van het Slim-raamwerk. We kunnen een aangepaste weergaveklasse maken die wordt uitgebreid Slim_View voor het toevoegen van enkele extra functies, zoals het instellen van een basislay-out, algemene instellingen, enz. Als u liever artikelen in Markdown schrijft, kunt u ook een Markdown-parser toevoegen.
We moeten ook kijken naar het verbeteren van de esthetiek van de applicatie. Ik gebruik liever een Twitter-bootstrap, omdat het echt heel gemakkelijk te gebruiken en aan te passen is. Ik denk niet dat het een goed idee is om hier op deze details in te gaan. Ik heb ze gecompileerd in een eenvoudige applicatie genaamd TextPress die hier kan worden gedownload.
Bijna alle platte blog-engines werken het liefst in de cloud. Verder wordt Git waarschijnlijk gebruikt voor het publiceren van artikelen. Met onze engine kunt u berichten maken met behulp van een eenvoudig tekstbestand en deze publiceren via de opdrachtregel. Omdat er geen admin-paneel is om te hacken, is het veel veiliger dan bijna elk ander content management-systeem. Bovendien is het gemakkelijk te hosten, want platformdiensten, zoals PHP Fog, stellen ons in staat om applicaties vrijelijk in de cloud te hosten.
Dus dat is het zo'n beetje. Laat het me weten als je nog vragen hebt in de reacties hieronder en heel erg bedankt voor het lezen!
