Share
In questo articolo, impareremo come creare un motore di blog di file flat in PHP usando il framework Slim. Se non capisci il gergo, non preoccuparti. Creeremo semplicemente un'applicazione di blogging spartana, che utilizza file di testo anziché un database per archiviare i dati.
Se sei un principiante, non preoccuparti! Inizieremo con le basi dell'utilizzo di Slim. Iniziamo dopo il salto!
Slim è un framework PHP RESTful leggero per la creazione di siti Web semplici. È ispirato a Sinatra, una struttura scritta in Ruby. Slim viene fornito con alcuni componenti minimi, come
Richiedere rispostaevistaquali sono gli unici componenti richiesti nel nostro motore di blog con file flat.
Per iniziare, configuriamo un'applicazione Hello World. Prima di ciò, devi scaricare il framework Slim sul tuo sistema. Non parleremo molto di Slim poiché è già stato trattato qui su Nettuts +. Dovresti idealmente avere i seguenti file nella tua cartella:
Accentsconagua
Sottile/ - Quadro sottileindex.php - Il file indice.htaccess - Per la riscrittura degli URL Ora apri index.php, dove vedrai un mucchio di HTML all'interno della sezione seguente. L'ho rimosso e sostituito con "Hello world". tu index.php dovrebbe, si spera, assomigliare a questo ora.
richiede 'Slim / Slim.php'; $ app = new Slim (); $ app-> get ('/', function () echo "Ciao mondo
";); $ app-> run (); Ho creato un Virtualhost nella mia macchina che è l'URL mostrato nello screenshot. Regola l'URL in base alla posizione di Slim nella tua macchina.
Vai all'URL e vedrai una home page con il testo "Hello world".
ottenere() è un metodo Slim, che prenderà una rotta come primo argomento e una corrispondente funzione di callback come ultima. Diverso da ottenere, possiamo avere percorsi per il POST, PUT e ELIMINA anche i verbi. Come Slim supporta PHP 5.3, la funzione di callback può essere, ed è, scritta come una funzione anonima.
Il prossimo passo è il rendering di un file PHP. Prima di continuare, creare una directory chiamata modelli per memorizzare tutti i nostri file modello. Qualsiasi file HTML statico o modello creato verrà inserito in questa cartella. Slim ci consente di specificare il percorso dei nostri file modello nella sua configurazione. Possiamo aggiungere una configurazione come mostrato di seguito.
$ app-> config (array ('templates.path' => './templates')); Creiamo una pagina su per il nostro blog. Crea un file PHP chiamato about.php e posizionarlo nel modelli cartella. Aggiungi il seguente codice ad esso:
Un motore per blog snello A proposito di pagina
Questa pagina è un esempio di route statica, che mostra un file php.
Affinché Slim possa elaborare una richiesta, è necessario definire un corrispondente Itinerario che può mappare a quell'URL. Nel nostro primo passo, abbiamo aggiunto un percorso per il indice o '/ ". Ora aggiungiamo un altro percorso per la nostra pagina.
$ app-> get ('/ about', function () usa ($ app) $ app-> render ('about.php');); Se si carica http: //slim.local/about nel tuo browser dovrebbe mostrare qualcosa del genere:
Abbiamo aggiunto un percorso alla pagina relativa, che verrà visualizzata about.php situato in ./ templates (ricorda il template.path variabile di configurazione?). Hai notato che abbiamo usato usare ($ app) dentro il ottenere metodo? Bene, questo è solo un modo per usare una variabile all'interno di una funzione anonima che è al di fuori del suo scopo.
Ora possiamo visualizzare una pagina modello per un percorso. È giunto il momento di pensare di visualizzare alcuni valori dinamici nel modello, poiché non è possibile eseguire il rendering e la pubblicazione di file statici per tutto il tempo. Possiamo assegnare valori da rendere in un modello dal render () metodo. Dovrebbe essere passato come secondo parametro come array associativo. Cambiamo il codice sopra per apparire così:
$ app-> get ('/ about', function () use ($ app) $ data = array ('heading' => 'About page', 'message' => 'Questa pagina è un esempio di route statica, rendering di un file php. '); $ app-> render (' about.php ', $ data);); E cambia leggermente il corpo del modello.
Noterai che puoi vedere la stessa pagina se ricarichi l'URL precedente. Le variabili utilizzate nel file modello sono le chiavi corrispondenti nell'array associativo.
Finora, abbiamo giocato con alcune route statiche, "/" e "/ about". Ora stiamo andando a creare un percorso dinamico, cioè un percorso che può rispondere a diversi URL.
$ app-> get ('/: param1 /: param2', funzione ($ param1, $ param2) usa ($ app) echo $ param1. '-'. $ param2;); Slim invoca sempre il primo percorso che corrisponde alla richiesta HTTP corrente. Ciò significa che tutti i percorsi statici devono essere definiti prima di percorsi dinamici.
Se si carica http: //slim.local/first-param/second-param nel tuo browser, verrà visualizzato first-param - second-param.
Il percorso di una variabile deve iniziare con un ':'. Slim passerà il valore di questa variabile come argomento alla nostra funzione di callback, in modo che possiamo analizzarlo ed eseguire un'operazione appropriata. Slim si aspetta esattamente due parametri per la rotta sopra poiché le due variabili di percorso sono obbligatorie. Se non è presente, Slim visualizzerà un errore 404. Possiamo rendere opzionale un parametro URL come mostrato nel passaggio successivo.
Per rendere facoltativo un parametro del percorso, riscrivi il codice precedente come mostrato di seguito:
$ app-> get ('/: param1 (/: param2 (/: param3))', function () usa ($ app) $ args = func_get_args (); foreach ($ args come $ arg) echo $ arg . '-';); Con questo, il secondo e il terzo parametro sono opzionali. Possiamo usare il func_get_args ()metodo per ottenere tutti gli argomenti passati alla funzione di callback.
Va bene, è tempo di occuparsi di affari seri. Ora abbiamo tutte le informazioni necessarie per creare un motore per blog a file flat. Mettiamo insieme le conoscenze sopra discusse per crearlo.
Dobbiamo creare un file system prima di mettere insieme tutti questi diversi componenti. Ecco un semplice file system per la nostra applicazione.
Questo è un file system minimalista con solo i file / le cartelle richiesti. Tutti gli articoli saranno conservati nel articoli cartella. Il risorse la cartella ospiterà i nostri file CSS e JavaScript così come le immagini. Sottile conterrà i file framework e template.
Se ti senti un po 'perso, ecco una rapida visione d'insieme di come è strutturata la nostra applicazione.
json_decode () funzione. Contenuto e metadati saranno separati con una riga vuota. Aggiungiamo un percorso che caricherà un articolo dalla cartella degli articoli in base all'URL.
// aggiungi la posizione dell'articolo nella configurazione $ app-> config (array ('templates.path' => './templates', 'article.path' => './articles' // posizione degli articoli)); // '/ post-url' caricherà il file post-url.txt. $ app-> get ('/: article', function ($ article) usa ($ app) $ path = $ app-> config ('article.path'); // apre il file di testo e lo legge $ handle = fopen ($ path. '/'. $ article. '.txt', 'r'); $ content = stream_get_contents ($ handle); // divide il contenuto per ottenere metadati $ content = explode ("\ n \ n" , $ content); $ rawMeta = array_shift ($ content); // i metadata sono codificati con json, quindi decodificali. $ meta = json_decode ($ rawMeta, true); $ content = implode ("\ n \ n", $ content ); $ article = array ('meta' => $ meta, 'content' => $ content); $ app-> render ('article.php', $ article);); Abbiamo aggiunto una rotta dinamica con un singolo parametro di rotta. La funzione di callback riceverà il valore per quel parametro, che dovrebbe essere un nome di file senza la sua estensione. Successivamente, estraiamo il valore di article.path variabile di configurazione, dove conserviamo i nostri articoli.
Nelle prossime due righe, leggiamo quel file e memorizziamo il suo contenuto in una variabile, $ content . Come ho detto nel paragrafo precedente, un articolo avrà metadati e contenuti reali che saranno separati da una singola riga ("\ n \ n"). Spesso, ci possono essere molte altre righe vuote nel contenuto di un articolo, che probabilmente interromperà il metodo corrente. Per evitare ciò, useremo il primo elemento per ottenere i metadati e ci uniremo al resto dell'array usando la stessa riga vuota. Poiché i metadati sono nel formato JSON, dobbiamo decodificarlo da qui e archiviarlo nel file $ meta schieramento.
Crea un file modello per rendere un articolo e posizionarlo nel modello cartella.
//article.php echo ''. $ meta ['titolo']. '
'; echo $ content;
Creiamo il nostro primo post sul blog ora. Crea un nuovo file chiamato prima article.txt, posizionalo nel articoli cartella e aggiungere il contenuto come mostrato di seguito. Assicurati di avere i metadati e il contenuto separati da una riga vuota.
//first-article.txt "title": "Questo è il mio primo articolo", "data": "15/02/2012", "slug": "primo articolo", "autore": "Nome autore" Crostata di marshmallow alla gelatina di frutta gelatina. Caramelle di cornetto caramelle torta al cioccolato muffin jelly bean liquirizia ... (copia incolla un po 'di labbra)
Eccellente! Puoi iniziare a pubblicare articoli ora. Ma aspetta! Non abbiamo ancora una pagina di elenco. Abbiamo bisogno di elencare tutti gli articoli disponibili nel nostro sistema, con il suo titolo e una piccola descrizione. Per fare questo, avremo bisogno di analizzare la cartella degli articoli per trovare tutti gli articoli e aggiungerli a un array leggendoli uno dopo l'altro.
$ app-> get ('/', funzione () usa ($ app) $ percorso = $ app-> config ('article.path'); $ dir = nuovo DirectoryIterator (percorso $); $ articles = array ( ) foreach ($ dir come $ file) 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 ", $ content); $ articles [$ file-> getFilename ()] = array ('meta' => $ meta, 'content' => $ content); $ app-> render ('index. php ', array (' articles '=> $ articles));); Qui, abbiamo aggiunto un percorso alla home page. Stiamo usando PHP integrato Directoryiterator classe per scorrere in loop ogni file nella directory. Ogni articolo è aggiunto al $ articoli array. Dal file di modello (index.php), possiamo scorrere questi articoli come mostrato di seguito.
foreach ($ articoli come $ articolo) echo "". $ article ['meta'] ['title']."
"; echo substr (strip_tags ($ article ['content']), 0,200). '... Leggi di più >>';
La nostra home page è pronta ora. Elencherà tutti gli articoli nel nostro blog, con il titolo corrispondente e una parte del contenuto.
Successivamente, creeremo una pagina 'archivi'. Poiché ci aspettiamo che la pagina degli archivi abbia filtri basati su anno, mese e data, aggiungeremo un percorso con parametri facoltativi. La pagina degli archivi supporta gli URL seguenti.
Per ottenere ciò, caricheremo tutti gli articoli e li filtreremo in base agli argomenti passati alla funzione di callback. Ho spostato tutto in una classe in modo da poter iniziare a riutilizzare il nostro codice. Un percorso che supporterà gli URL di cui sopra sarà simile a questo:
// assegna $ this a un'altra variabile in quanto non è supportata all'interno della chiusura $ blog = new Blog (); $ slim-> get ('/ archives (/: yyyy (/: mm (/: dd)))', function () usa ($ blog, $ slim) ); Si noti che in questa rotta, l'anno, il mese e la data sono parametri facoltativi. / archivio è l'unica parte richiesta dell'URL. Successivamente, dobbiamo implementare questa rotta che risponderà in base ai parametri opzionali.
$ args = func_get_args (); // carica tutti gli articoli $ articles = $ blog-> loadArticles (); $ archives = array (); // controlla il conteggio ($ args) per i parametri opzionali di route if (count ($ args)> 0) switch (count ($ args)) caso 1: // solo anno è presente $ format = 'Y'; $ date = $ dateFormat ($ args, $ format); rompere; caso 2: // anno e mese sono presenti $ format = 'Y-m'; $ date = $ dateFormat ($ args, $ format); rompere; caso 3: // anno, mese e data sono presenti $ format = 'Y-m-d'; $ date = $ dateFormat ($ args, $ format); rompere; // filtro articoli foreach ($ articoli come $ articolo) if ($ dateFormat ($ article ['meta'] ['date'], $ format) == $ date) $ archives [] = $ article; else $ archives = $ articles; // rendering archivi $ slim-> render ('archives.php', array ('archivi' => $ archivi)); Dentro il interruttore dichiarazione, creiamo la data da filtrare usando gli argomenti passati. Questa data viene confrontata con la data di ciascun articolo e, se corrispondono, viene aggiunta al $ archivi schieramento. $ DateFormat () è una funzione anonima all'interno del percorso per formattare le date.
$ dateFormat = function ($ args, $ format) $ temp_date = is_array ($ args)? implode ('-', $ args): $ args; $ date = new DateTime ($ temp_date); return $ date-> format ($ format); ; Possiamo scrivere le condizioni per un percorso che dovrebbe essere soddisfatto dagli argomenti, per convalidare l'anno, il mese e la data passati al percorso.
$ slim-> get ('/ archives (/: yyyy (/: mm (/: dd))), function () usa $ blog ) -> condizioni (array (' yyyy '=>' (19 | 20) \ d \ d ',' mm '=>' (0 [1-9] | 1 [0-2]) ',' dd '=>' (0 [1-9] | [1-2] [0-9] | 3 [0-1]) ')); Qui, l'anno dovrebbe iniziare con 19 o 20 seguiti da due cifre qualsiasi. Il mese dovrebbe essere tra 1 e 12 e la data dovrebbe essere tra 01 e 31.
Ecco la pagina degli archivi che ho creato con il codice sopra. Se hai notato che ho usato Twitter Bootstrap per applicare alcuni stili di base, ottieni un cookie extra!
Bene, ora possediamo un modello funzionante di un motore di blog con file flat. La prossima cosa che dobbiamo fare è organizzare l'applicazione per evitare la duplicazione del codice e aggiungere funzionalità come commenti e così via. Spostiamo questo codice da index.php in una classe separata per un'organizzazione migliore.
Finora, abbiamo usato il vista classe della struttura sottile. Possiamo creare una classe di visualizzazione personalizzata che si estenderà Slim_View per aggiungere alcune funzionalità aggiuntive come l'impostazione di un layout di base, le impostazioni globali, ecc. Se preferisci scrivere articoli in Markdown, puoi includere anche un parser Markdown.
Dovremmo anche cercare di migliorare l'estetica dell'applicazione. Preferisco usare il bootstrap di Twitter dato che è davvero molto facile da usare e personalizzare. Non penso che sia una buona idea approfondire questi dettagli qui. Li ho compilati in una semplice applicazione chiamata TextPress che può essere scaricata qui.
Quasi tutti i motori di blog su file flat preferiscono vivere nel cloud. Ulteriore Git è probabilmente usato per la pubblicazione di articoli. Con il nostro motore, puoi creare post usando un semplice file di testo e pubblicarlo usando la riga di comando. Poiché non vi è alcun pannello di amministrazione da hackerare, è molto più sicuro di quasi qualsiasi altro sistema di gestione dei contenuti. Soprattutto, è facile da ospitare, dal momento che i servizi di piattaforma, come PHP Fog, ci permettono di ospitare applicazioni liberamente nel cloud.
Quindi questo è tutto. Fatemi sapere se avete domande nei commenti qui sotto e vi ringrazio tanto per la lettura!
