Share
In den letzten Wochen hat NETTUTS einige großartige Tutorials veröffentlicht, um zu lernen, wie Sie mit PHP und MySQL einfache Webanwendungen wie eine Shout-Box erstellen können. Heute werden wir unser Wissen über PHP und MySQL noch weiter ausbauen, indem wir einen einfachen Blog erstellen. Zwar gibt es unzählige exzellente kostenlose Blog-Plattformen. Ziel dieses Tutorials ist es jedoch nicht, ein "besseres" Blog zu erstellen, sondern die Erstellung eines Blogs, um sich mit fortgeschrittenen Datenbankstrukturtechniken und dem effizienteren Einsatz von Daten durch Verwendung von Objekten in vertraut zu machen PHP.
Simple Blog Files.zip
benmillsdesigns.com/simpleblog/
Für dieses Tutorial wird vorausgesetzt, dass Sie über Grundkenntnisse in PHP, MySQL, XHTML und später in jQuery / JavaScript verfügen.
Bevor wir in unseren MySQL-Client wechseln und mit dem Erstellen unserer Tabellen beginnen, sollten wir in unserem Blog festlegen, was wir wollen. Das Offensichtliche, was wir halten müssen, sind Blogbeiträge, die in jedem Beitrag einen Titel, den Beitrag, einen Autor und das Datum enthalten sollten, an dem er veröffentlicht wurde.
Jetzt könnten wir nur eine Tabelle für diese Informationen erstellen und höchstwahrscheinlich die Erstellung eines einfachen Blogs durchführen. Mit nur einer Tabelle haben wir jedoch nicht so viel Kontrolle über unsere Daten. Zum Beispiel könnten wir den Namen des Autors in derselben Tabelle wie der Blogbeitrag speichern. Was aber, wenn wir auch die E-Mail des Autors speichern möchten? Sicher! Wir fügen einfach ein weiteres Feld zu unserer Tabelle hinzu, wäre die naheliegende Lösung.
Das Problem tritt auf, wenn Sie auf der Straße die E-Mail-Adresse dieses Autors ändern möchten. Jetzt müssen Sie es für jeden einzelnen Blogeintrag ändern, den diese Person erstellt hat.
Was wir also tun werden, ist eine separate Tabelle mit dem Namen "People". In dieser werden wir alle Informationen speichern, die wir vom Autor benötigen - wie E-Mails, URLs, deren Namen und eine eindeutige ID. Dann werden wir in unserer Blogpost-Tabelle auf die Person verweisen, die wir mit der eindeutigen ID dieser Person verwenden möchten. Diese ID wird als Fremdschlüssel bezeichnet, und die Beziehung zwischen der Blogpostentabelle und der People-Tabelle wird als Eins-zu-Viele-Beziehung bezeichnet.
Eine andere Sache, die wir in unserem Blog haben möchten, ist ein Tag für jeden Blogeintrag. Auch hier möchten wir unsere Datenbank effizienter gestalten, sodass wir eine separate Tabelle für unsere Tags erstellen. Was tun wir jetzt? Sollten wir in der Blogpost-Tabelle ein Feld erstellen, das einen Fremdschlüssel für unser Tag darstellt? Das Problem bei der Verwendung einer Eins-zu-Eins-Beziehung ist, dass Blogbeiträge manchmal mehr als ein Tag haben. Wir werden also wieder eine Eins-zu-Viele-Beziehung verwenden. Dazu müssen wir eine weitere Tabelle erstellen, die als "blog_post_tags" bezeichnet wird und zwei Fremdschlüssel enthält. Der eine ist die ID des Blogposts und die andere die Tag-ID, der der Blogpost zugeordnet ist. Auf diese Weise können wir einem Blog-Post so viele Tags zuweisen, wie wir möchten, aber die Informationen zu diesem bestimmten Tag können Sie mit einer einfachen MySQL-Abfrage in allen Posts bearbeiten.
Nachdem wir nun beschrieben haben, wie unsere Datenbank aussehen soll, erstellen wir sie. Ich werde PhpMyAdmin verwenden, da dies der am häufigsten verwendete MySQL-Admin-Client ist. Bei der Erstellung Ihrer Datenbank-, Tabellen- und Feldnamen gibt es verschiedene Namenskonventionen. Ich persönlich benutze gerne alle Kleinbuchstaben und Unterstriche anstelle von Leerzeichen.
Hinweis: Wenn Sie weder PHP noch MySQL auf Ihrem System oder einen Server haben, auf dem PHP ausgeführt werden kann, empfehle ich Ihnen, eine eigenständige Installation von Apache, PHP und MySQL herunterzuladen. MAMP ist gut für Macs und WAMP ist gut für PCs.
Zuerst müssen wir unsere Datenbank erstellen, ich werde sie "nettuts_blog" nennen..
Als Nächstes erstellen wir unsere Tabellen. das erste wird "blog_posts" sein.
"blog_posts" hat fünf Felder: "id", "title", "post", "author_id" und "date_posted". Für "id" machen wir ihn zum Primärschlüssel und setzen ihn auf auto-inkrement. Was dies tun wird, ist die Generierung unserer einzigartigen ID für uns. Jedes Mal, wenn wir einen Beitrag hinzufügen, wird ihm eine Nummer zugewiesen, die bei eins beginnt und für so viele Beiträge wie möglich erscheint.
Jetzt müssen wir auch den Variablentyp für jedes Feld festlegen. Die ID wird auf den Typ int gesetzt, kurz für Integer, da es sich nur um eine Zahl handeln kann, und wir werden die maximale Länge auf 11 setzen. Das Feld "title" wird auf den Typ varchar mit einer maximalen Länge von 255 gesetzt. Das Feld "Beitrag" wird vom Typ "Text" sein und wir werden keine maximale Länge festlegen, da die Beiträge sehr lang sein können. "author_id" ist identisch mit "id", aber wir werden ihn nicht als Primärschlüssel festlegen oder automatisch inkrementieren lassen, und "date_posted" wird auf "Date" gesetzt..
Unser nächster Tisch wird "Menschen" sein. Wir nennen das nicht "Autoren", weil wir in der Zukunft vielleicht die Möglichkeit haben möchten, sich zu registrieren und Kommentare zu schreiben, und diese Leute würden nicht als Autoren betrachtet.
"Personen" enthält außerdem fünf Felder: "ID", "Vorname", "Nachname", "URL" und "E-Mail"..
"id" wird als int, der Primärschlüssel und zum automatischen Inkrementieren gesetzt, genauso wie wir die id von "blog_posts" setzen. "first_name", "last_name", "url" und "email" werden auf den Typ varchar mit einer maximalen Länge von 255 gesetzt.
Unsere nächste Tabelle wird "Tags" sein und vorerst nur zwei Felder enthalten: "ID" und "Name". Auf der Straße könnten wir dies durch Hinzufügen einer Beschreibung komplexer gestalten, aber für dieses Tutorial werden wir dies nicht tun. Wie zuvor wurde "id" als int, der Primärschlüssel und als automatisches Inkrement gesetzt. "name" ist vom Typ varchar und hat eine maximale Länge von 255.
Und unsere letzte Tabelle "blog_post_tags" enthält nur zwei Felder: "blog_post_id" und "tag_id". Beide werden auf den Typ int mit einer maximalen Länge von 11 eingestellt. Wie Sie höchstwahrscheinlich bemerkt haben, haben wir keinen Primärschlüssel für diese Tabelle festgelegt. Dies liegt daran, dass wir niemals Daten aus dieser Tabelle erhalten, es sei denn, wir fragen nach einem bestimmten Blogbeitrag oder nach allen Posts einer bestimmten Tag-ID.
Bevor wir mit unserem eigentlichen PHP-Code beginnen, müssen wir unsere Dateien und Ordner erstellen. Für dieses Tutorial haben wir unsere index.php in unserem Stammordner und dann einen Include-Ordner, der unser CSS-Stylesheet, unsere JavaScript-Dateien, enthält .php das wird Verweise auf unsere Objekte und MySQL-Verbindung enthalten und blogpost.php, das unser BlogPost-Objekt enthält.
Jetzt, da wir unsere Datenbank haben, müssen wir die Objekte in PHP erstellen, die die Daten für uns verarbeiten. Objekte in der Programmierung sind eine Möglichkeit, verschiedene Attribute (als Variablen) und Methoden zusammenzuführen, die sich alle auf dasselbe beziehen. Objekte helfen uns auch bei der Organisation unserer Programme. Bevor wir uns für unseren Blog in unsere Objekte stürzen, erstellen wir einfach ein einfaches Objekt, damit wir veranschaulichen können, was sie in einem "real life" -Begriff sind.
Unser Objekt wird "Fahrrad" genannt. Nun gibt es zwei Arten von Objekten, Eigenschaften und Methoden. Eigenschaften definieren das Objekt und die Methoden sind das, was das Objekt macht. Zum Beispiel hätte unser Bike-Objekt Eigenschaften wie Radgröße, Anzahl der Gänge und vielleicht die Rahmengröße. Für Methoden könnten wir so etwas wie "Pedal" haben.
Um zu unserem Blog zurückzukehren, benötigen wir nur noch ein Objekt namens "BlogPost". BlogPost verfügt über sechs Eigenschaften, eine ID, einen Titel, einen Beitrag, einen Autor, Tags und ein Veröffentlichungsdatum. Also machen wir es in PHP.
Um ein Objekt in PHP zu definieren, definieren wir es als "Klasse". Eine Klasse ist die Struktur eines jeden Objekts oder wie es von Wikipedia beschrieben wird: "In der objektorientierten Programmierung ist eine Klasse ein Programmiersprachen-Konstrukt, das als Entwurf für die Erstellung von Objekten verwendet wird. Dieser Entwurf enthält Attribute und Methoden, die alle erstellten Objekte enthalten Aktie." (http://en.wikipedia.org/wiki/Concrete_class). Wir werden unsere blogpost.php-Seite öffnen und unser erstes Objekt definieren.
Anmerkung: In jedem Abschnitt des Tutorials werde ich die öffnenden und schließenden PHP-Tags weglassen. "msgstr "Sie müssen sie am Anfang und am Ende Ihres Dokuments einfügen.
Klasse BlogPost
In unserer Klasse müssen wir zuerst unsere Eigenschaften definieren. Dazu müssen wir Variablen erstellen - aber mit "public" davor. Nur eine kurze Anmerkung, wenn Sie PHP4 verwenden, müssen Sie "var" anstelle von "public" verwenden..
Klasse BlogPost public $ id; öffentlicher $ title; öffentlicher $ post; öffentlicher $ Autor; öffentliche $ tags; public $ datePosted;
Nun, da wir alle unsere Eigenschaften definiert haben, möchten wir unsere erste Methode definieren. Methoden werden auch als Funktionen beschrieben, der Hauptunterschied besteht jedoch darin, dass eine Methode eine Funktion innerhalb eines Objekts ist. Alle Methoden sind also auch Funktionen, aber nicht alle Funktionen sind Methoden.
Unsere erste Methode wird ein Konstruktor sein. Diese Methode wird automatisch aufgerufen, wenn wir eine neue Instanz des BlogPost-Objekts erstellen.
Die allgemeine Verwendung eines Konstruktors besteht darin, dass Sie ein neues Objekt erstellen und die Eigenschaften dieses Objekts schnell festlegen können.
Wir wollen also eine neue Funktion namens __construct () erstellen und wir werden fünf Werte übergeben: id, title, post, author id und date posted. Für jeden Variablennamen setzen wir vor dem Wort "in", damit wir innerhalb unserer Funktionen erkennen können, welche Variablen übergeben werden und welche Variablen bereits vorhanden sind.
Klasse BlogPost public $ id; öffentlicher $ title; öffentlicher $ post; öffentlicher $ Autor; öffentliche $ tags; public $ datePosted; Funktion __construct ($ inId, $ inTitle, $ inPost, $ inAuthorId, $ inDatePosted)
Das Problem hierbei ist, dass bei diesem aktuellen Code jedes Mal, wenn wir eine neue Instanz von BlogPost erstellen, alle diese Eigenschaften bereitgestellt werden müssen. Was aber, wenn wir einen neuen Blogeintrag erstellen möchten und diese Variablen noch nicht definiert haben? Um dies zu handhaben, müssen wir die Argumente für unsere Funktion "überladen". Wenn wir also die Funktion aufrufen und keines der Argumente übergeben, wird sie automatisch auf den Standardwert gesetzt.
Funktion __construct ($ inId = null, $ inTitle = null, $ inPost = null, $ inPostFull = null, $ inAuthorId = null, $ inDatePosted = null)
Wie Sie sehen, setzen wir zur Erreichung unserer Aufgabe nur jedes Argument auf den Wert "null". Jetzt müssen wir in unserem Konstruktor jede unserer Variablen auf unsere übergebenen Werte setzen. Um dies zu tun, möchten wir sie auf das Objekt setzen, in dem wir uns gerade befinden. Wir können dies mit dem Schlüsselwort "this" tun. Im Gegensatz zu vielen anderen Sprachen für den Zugriff auf eine Eigenschaft in PHP verwenden Sie "->", wobei Sie in den meisten Sprachen (I.E. JavaScript, ASP.NET) ".".
Funktion __construct ($ inId = null, $ inTitle = null, $ inPost = null, $ inPostFull = null, $ inAuthorId = null, $ inDatePosted = null) $ this-> id = $ inId; $ this-> title = $ inTitle; $ this-> post = $ inPost;
Dies funktioniert für ID, Titel und Beitrag. Aber was ist mit unseren anderen? Für das Datum müssen wir die Daten, die wir von MySQL erhalten haben, neu formatieren, um lesbarer zu sein. Das ist leicht zu erreichen. Wir explodieren es einfach (auch bekannt als Splitting in anderen Programmiersprachen) und setzen es dann wieder zusammen. MySQL gibt es in diesem Format jjjj-mm-tt. Wenn wir es mit "-" als Trennzeichen auflösen, erhalten wir ein Array mit drei Werten. Der erste hält unser Jahr, der nächste den Monat und der letzte ist der Tag. Jetzt müssen wir sie nur noch in einem beliebigen Format zusammenstellen. Ich gehe mit MM / TT / JJJJ.
Accentsconagua
$ splitDate = explode ("-", $ inDatePosted); $ this-> datePosted = $ splitDate [1]. "/". $ splitDate [2]. "/". $ splitDate [0]; Für den Autor müssen wir nur die Datenbank nach der Person mit der ID unserer Autoren-ID fragen. Wir können dies mit einer einfachen MySQL-Abfrage tun.
$ query = mysql_query ("SELECT Vorname, Nachname FROM Personen WHERE id =". $ inAuthorId); $ row = mysql_fetch_assoc ($ query); $ this-> author = $ row ["first_name"]. "". $ row ["last_name"]; Jetzt werden die Tags etwas schwieriger. Wir müssen mit der Datenbank sprechen, also müssen wir eine MySQL-Abfrage erstellen. Wir machen uns jetzt keine Sorgen um die Datenbankverbindung, die außerhalb dieser Klasse definiert wird. Jetzt haben wir nur noch die ID des Blogposts. Wir können das mit den Blogposts-Tags in unserer blog_post_tags-Tabelle vergleichen, aber dann erhalten wir nur die ID des Tags zurück und müssen eine weitere Abfrage durchführen, um die Informationen zum Tag zu erhalten. Das ist nicht gut; Wir möchten effizient sein, also machen wir es mit einer einzigen Abfrage!
Um dies zu tun, machen wir einen sogenannten linken Join. Das bedeutet, dass wir auch Daten aus einer anderen Tabelle auswählen, aber nur dann, wenn sie mit den Daten von "links" oder unseren anderen ausgewählten Daten übereinstimmen. Lassen Sie uns also zunächst alle Tag-IDs abrufen, die der ID unseres Blog-Posts in der Tabelle blog_post_tags zugeordnet sind.
$ query = mysql_query ("SELECT * FROM blog_post_tags WHERE blog_post_tags.blog_post_id =". $ inId); Nun fügen wir unseren linken Join hinzu und sagen unserer Anfrage, dass wir nur die Daten in der Tag-Tabelle haben wollen:
$ query = mysql_query ("SELECT-Tags. * FROM blog_post_tags LEFT JOIN (Tags) ON (blog_post_tags.tag_id = tags.id) WHERE blog_post_tags.blog_post_id =". $ inId); Nun wählt die Abfrage alle aus den Tags und den Tabellen blog_posts_tags aus, wobei zuerst blog_post_tags.blog_post_id der von uns angegebenen entspricht und dann auch die Informationen zu jedem Tag zurückgibt, das diese tag_id enthält, die sich in derselben Datenzeile wie unsere blog_post_id befindet.
Nun wollen wir diese Daten in PHP mit einer einfachen while-Schleife verarbeiten. Wir werden auch zwei Arrays erstellen, die unsere Daten enthalten: eines für den Tag-Namen und das andere für die Tag-ID. Wir werden auch eine Zeichenfolge erstellen, die alle unsere Tags enthält. Wir setzen es zuerst auf "No Tags", damit wir, wenn wir keine Daten aus unserer MySQL-Abfrage zurückgeben, zurückgeben, dass wir keine Tags haben. Andernfalls wird dieser Wert mit den Tag-Namen überschrieben.
$ postTags = "Keine Tags"; $ tagArray = array (); $ tagIDArray = array (); while ($ row = mysql_fetch_assoc ($ query) array_push ($ tagArray, $ row ["name"]); array_push ($ tagIDArray, $ row ["id"]);
Jetzt prüfen wir, ob das Array eine Länge größer als Null hat (wir möchten nicht den gesamten zusätzlichen Code ausführen, wenn dies nicht erforderlich ist). Als Nächstes werden wir für jedes Tag in unserem Tag-Namensarray eine Folge von Tags verketten. Wir verwenden eine einfache if-else-Anweisung.
if (sizeof ($ tagArray)> 0) foreach ($ tagArray als $ tag) if ($ postTags == "Keine Tags") $ postTags = $ tag; else $ postTags = $ postTags. ",". $ tag; $ this-> tags = $ postTags;
Sie haben wahrscheinlich bemerkt, dass wir die Tag-ID-Arrays nicht verwendet haben. Wir werden diese erst einmal in Ruhe lassen und später zu ihnen zurückkommen. Wir wollen einfach nur unseren Blog zum Laufen bringen.
Der letzte Schritt für unsere Klasse ist das Hinzufügen von if-Anweisungen für jede Eigenschaft. Wenn wir nichts übergeben, wird nicht versucht, die Eigenschaft des aktuellen Objekts auf nichts zu setzen (dies führt zu einem Fehler). Hier ist die gesamte BlogPost-Klasse mit den hinzugefügten if-Anweisungen:
id = $ inId; if (! empty ($ inTitle)) $ this-> title = $ inTitle; if (! empty ($ inPost)) $ this-> post = $ inPost; if (! empty ($ inDatePosted)) $ splitDate = explode ("-", $ inDatePosted); $ this-> datePosted = $ splitDate [1]. "/". $ splitDate [2]. "/". $ splitDate [0]; if (! empty ($ inAuthorId)) $ query = mysql_query ("SELECT vorname, nachname FROM people WHERE id =". $ inAuthorId); $ row = mysql_fetch_assoc ($ query); $ this-> author = $ row ["first_name"]. "". $ row ["last_name"]; $ postTags = "Keine Tags"; if (! empty ($ inId)) $ query = mysql_query ("SELECT-Tags. * FROM blog_post_tags LEFT JOIN (Tags) ON (blog_post_tags.tag_id = tags.id) WHERE blog_post_tags.blog_post_id =". $ inId); $ tagArray = array (); $ tagIDArray = array (); while ($ row = mysql_fetch_assoc ($ query)) array_push ($ tagArray, $ row ["name"]); array_push ($ tagIDArray, $ row ["id"]); if (sizeof ($ tagArray)> 0) foreach ($ tagArray als $ tag) if ($ postTags == "Keine Tags") $ postTags = $ tag; else $ postTags = $ postTags. ",". $ tag; $ this-> tags = $ postTags; ?> Jetzt, da unsere Objektklasse abgeschlossen ist, ist das meiste an hartem Material erledigt! Jetzt müssen wir nur noch unsere Datenbankverbindung und den HTML-Code einrichten, um unsere Beiträge anzuzeigen!
Bevor wir etwas tun, müssen wir unsere Includes.php-Datei einrichten, um einen Verweis auf unser BlogPost-Objekt zu enthalten und eine Verbindung zu unserer MySQL-Datenbank herzustellen. Lassen Sie uns zunächst unser Objekt mit einer einfachen include-Anweisung einschließen:
Include 'blogpost.php';
Jetzt können wir unsere Datenbankverbindung hinzufügen:
$ connection = mysql_connect ("localhost", "username", "password") oder die ("Leider konnte keine Verbindung zum Datenbankserver hergestellt werden.
"); $ database =" nettuts_blog "; mysql_select_db ($ database, $ connection) oder die ("Leider konnten wir keine Verbindung zur Datenbank herstellen.
"); Als Nächstes müssen wir unsere Blogbeiträge aus der Datenbank abrufen. Dazu erstellen wir eine Funktion, die bis zu zwei Argumente annehmen kann. Wir werden beide überladen; Sie können die Funktion also mit 0, 1 oder 2 Argumenten aufrufen.
Funktion GetBlogPosts ($ inId = null, $ inTagId = null)
In unserer Funktion müssen wir prüfen, welche Argumente übergeben wurden, und entsprechend unsere MySQL-Abfrage erstellen.
Funktion GetBlogPosts ($ inId = null, $ inTagId = null) if (! empty ($ inId)) else if (! empty ($ inTagId)) else
Was wir hier tun, ist die Frage, ob jedes Argument nicht leer ist. Der Grund, warum wir die leere Funktion verwenden, anstatt nur den Standardvergleich "! = Null" durchzuführen, liegt darin, dass empty nicht nur prüft, ob die Variable null ist, sondern ob es auch leer (IE ""). Jetzt schreiben wir eine Abfrage, je nachdem, welche Variablen wir haben. Wenn wir eine Blogpost-ID übergeben, möchten wir nur diesen einzelnen Blogpost, wenn wir der Funktion eine inTagId geben, möchten wir alle Posts mit diesem Tag und ansonsten möchten wir nur alle Blogposts in unserer Datenbank.
if (! empty ($ inId)) $ query = mysql_query ("SELECT * FROM blog_posts WHERE id =". $ inId. "ORDER BY id DESC"); else if (! empty ($ inTagId)) $ query = mysql_query ("SELECT blog_posts. * FROM blog_post_tags LEFT JOIN (blog_posts) ON (blog_post_tags.postID = blog_posts.id) WHERE blog_post_tags.tagID =". ORDER BY blog_posts.id DESC "); else $ query = mysql_query ("SELECT * FROM blog_posts ORDER BY id DESC"); Der nächste Schritt besteht darin, die von jeder Abfrage zurückgegebenen Daten zu verarbeiten, die Objekte zu erstellen und sie anschließend einem Array hinzuzufügen, das zurückgegeben werden soll.
$ postArray = array (); while ($ row = mysql_fetch_assoc ($ query)) $ myPost = new BlogPost ($ row ["id"], $ row ['title'], $ row ['post'], $ row ['postfull']), $ row ['firstname']. "". $ row ['lastname'], $ row ['dateposted']); array_push ($ postArray, $ myPost); return $ postArray;
Hier ist der gesamte Code der Includes.php:
Leider konnte keine Verbindung zum Datenbankserver hergestellt werden."); $ database =" nettuts_blog "; mysql_select_db ($ database, $ connection) oder die ("Leider konnten wir keine Verbindung zur Datenbank herstellen.
"); Funktion GetBlogPosts ($ inId = null, $ inTagId = null) if (! empty ($ inId)) $ query = mysql_query (" SELECT * FROM blog_posts WHERE id = ". $ inId." ORDER BY id DESC "); else if (! empty ($ inTagId)) $ query = mysql_query (" SELECT blog_posts. * FROM blog_post_tags LEFT JOIN (blog_posts) ON (blog_post_tags.postID = blog_posts.id) WHERE blog_post_tags.tagID = " tagID. "ORDER BY blog_posts.id DESC"); else $ query = mysql_query ("SELECT * FROM blog_posts ORDER BY id DESC"); $ postArray = array (); while ($ row = mysql_fetch_assoc ($ query) ) $ myPost = new BlogPost ($ row ["id"], $ row ['title'], $ row ['post'], $ row ['postfull']), $ row ["author_id"], $ row ['dateposted']); array_push ($ postArray, $ myPost); return $ postArray;?> Jetzt können wir uns mit der Anzeige unserer Daten fortbewegen, unsere index.php-Datei öffnen und eine einfache HTML-Seite einrichten. In unserem Körper erstellen wir eine Abteilung mit der ID "main", die unser Blog enthält. Wir werden unserem Blog einen Titel geben und dann ein zweites Div in main haben, das "blogPosts" genannt wird..
Mein einfacher Blog
In unserem blogPosts-Div werden wir ein wenig PHP einfügen, damit wir unsere Beiträge anzeigen können. Zuerst fügen wir unsere "include.php" -Datei ein und rufen dann die GetBlogPosts-Funktion ohne Argumente auf, um alle unsere Blogbeiträge abzurufen und diese auf ein Array namens blogPosts zu setzen.
Jetzt werden wir eine foreach-Schleife verwenden, um unsere Blogeinträge anzuzeigen. Eine foreach-Schleife macht für uns jetzt ein Array und führt den Code in der Schleife für jedes Element im Array aus. Sie können auch eine normale for-Schleife verwenden, um dies zu erreichen, aber eine foreach-Schleife erfordert weniger Code.
foreach ($ blogPosts als $ post)
Innerhalb der Schleife verwenden wir $ post als aktuelles Array-Element. Da $ blogPosts ein Array von BlogPost-Objekten ist, können Sie einfach mit "->" auf jede gewünschte Eigenschaft zugreifen. Beginnen wir damit, einfach den Titel jedes Blogposts auf unserer Seite auszusprechen und einfach ein
- als Beispiel.
foreach ($ blogPosts as $ post) echo $ post-> title. "
";
Wenn wir in unsere Datenbank gehen und einige falsche Daten einfügen, öffnen Sie index.php in einem Browser. Wir werden so etwas wie folgt erhalten:
Lassen Sie uns wirklich unsere Beiträge in HTML erstellen. Jeder Beitrag wird in einem Div mit einer Klasse "Post" verpackt. Dann haben wir den Beitragstitel in einem h1-Tag und den eigentlichen Beitrag in einem
Etikett.
foreach ($ blogPosts as $ post) echo ""; Echo"";". $ post-> title."
"; Echo"". $ post-> post."
"; Echo"
Geben Sie jedem Beitrag außerdem eine Fußzeile, die den Autor des Beitrags, das Veröffentlichungsdatum und die Tags des Beitrags enthält. Wir werden alle diese Informationen innerhalb eines Bereichs mit einer Klasse "Fußzeile" einfügen..
foreach ($ blogPosts as $ post) echo ""; Echo"";". $ post-> title."
"; Echo"". $ post-> post.""; Echo"Posted By: ". $ Post-> author." Posted on: ". $ Post-> datePosted." Tags: ". $ Post-> tags.""; Echo"
Nun schauen wir uns unsere index.php-Datei noch einmal in einem Browser an:
Sieht aus wie alles funktioniert! Als nächstes wollen wir noch etwas Styling hinzufügen.
Viel besser; Sie können dies hier online anzeigen oder auf die großen "Demo" -Schaltflächen klicken. Das wars für dieses Tutorial. In einem nachfolgenden Tutorial werden wir unserem Blog weitere Funktionen hinzufügen, darunter auch einige nützliche AJAX-Funktionen!
Ich hoffe, Sie haben jetzt ein besseres Verständnis dafür, wie objektorientierte Programmierung funktioniert. Selbst wenn Sie den Großteil Ihrer Entwicklung mit Hilfe eines Frameworks durchführen, ist es sehr wichtig, ein grundlegendes Verständnis der Grundlagen zu haben. Wenn Sie spezielle Fragen zu diesem Tutorial haben, zögern Sie nicht, mich an @benemills zu twittern. Ich möchte mich ganz besonders bei James Padolsey bedanken, der mir bei diesem Artikel geholfen hat.
Bleiben Sie dran für Teil 2!
