So erstellen Sie ein objektorientiertes Blog mit PHP

German (Deutsch) translation by Wilhelm Wolf (you can also view the original English article)

In den letzten Wochen NETTUTS hat geschrieben durchaus ein paar tolle tutorials, wie man die ersten Schritte mit PHP und MySQL erstellen von einfachen web-Anwendungen wie eine shout-box. Heute werden wir unsere Kenntnisse in PHP und MySQL einen Schritt weiter, indem Sie erstellen eine einfache blog. Zwar gibt es unzählige ausgezeichnete Kostenlose blog-Plattformen, die in diesem Lernprogramm nicht um ein "besser" - blog, sondern auch, um den Prozess der Herstellung ein blog zu erfahren, erweiterten Datenbank-Struktur, die Techniken und die Verwendung von Daten effizienter durch die Verwendung von Objekten in PHP.

Einfache Blog Files.zip

benmillsdesigns.com/simpleblog/

Für dieses tutorial wird davon ausgegangen, dass Sie einige grundlegende Kenntnisse in PHP, MySQL, XHTML, und später auf jQuery / JavaScript.

Teil 1) Erstellung unserer Datenbank

Bevor wir in unsere MySQL-client und starten Sie die Erstellung unsere Tische, wir sollten zu legen, was wir wollen in unserem blog. Die offensichtliche Sache, die wir halten müssen, ist die blog-posts und in jedem post sollte es einen Titel, der post, ein Autor, und das Datum es gesendet wurde.

Jetzt konnten wir nur eine Tabelle zu halten, die Informationen, und die meisten wahrscheinlich erreichen, ist die Schaffung eines einfachen blog, aber mit nur einem Tisch, das wir nicht so viel Kontrolle über unsere Daten. Zum Beispiel könnten wir speichern nur den Namen des Autors in der gleichen Tabelle wie die blog-post, aber was ist, wenn wir wollen, auch zu speichern, den Autor der E-Mail? Sicher!!! Wir fügen Sie einfach ein weiteres Feld in unserer Tabelle wäre die naheliegende Lösung.

Das problem kommt, wenn auf der Straße Sie möchten, ändern Sie die E-Mail-Adresse des Autors. Jetzt haben Sie Sie ändern es für jeden einzelnen blog-post, dass die person geschaffen hat.

Also, was wir tun werden, ist eine separate Tabelle namens "Personen" und in diesem speichern wir alle Informationen, die wir benötigen, aus der Autor - wie E-Mails, URLs, Ihren Namen und eine eindeutige ID. Dann in unserem blog-post Tabelle, die wir auf die person, die wir wollen, dass die person eindeutige ID. Diese id wird bezeichnet als foreign key und die Beziehung zwischen den blog-post, der Tisch und die Menschen, die Tabelle heißt eine eins-zu-viele-Beziehung.

Eine andere Sache, möchten wir in unserem blog ein tag für jeden blog-post. Wieder wollen wir unsere Datenbank effizient, so werden wir einen separaten Tisch für unsere Umbauten. Nun, was tun wir? Sollten wir ein Feld erstellen, in blog-post-Tabelle, die einen Fremdschlüssel für unseren tag? Das problem bei der Verwendung einer eins-zu-eins-Beziehung diese Zeit ist manchmal blog-posts haben mehr als einen tag; also noch einmal, verwenden wir eine eins-zu-viele-Beziehung. Um dies zu tun, benötigen wir zum erstellen einer anderen Tabelle aufgerufen wird, so etwas wie "blog_post_tags" , hält zwei foreign-keys, wird der blog-post ID und die anderen werden die tag-ID, die den blog-post zugeordnet ist. Auf diese Weise können wir weisen so viele tags, wie wir wollen, um einen blog-post, können aber weiterhin Bearbeiten Sie die Informationen zu diesem bestimmten tag über alle Beiträge, die mit einer einfachen MySQL Abfrage.

Nun, wir haben dargelegt, was wir wollen, unsere Datenbank zu schauen, wie, wir schaffen es. Werde ich mit PhpMyAdmin da, das ist die am meisten verwendete MySQL-admin-client. Es gibt ein paar verschiedene Benennungskonventionen können Sie verwenden, wenn Sie Ihre Datenbank -, Tabellen-und Feldnamen. Ich persönlich mag zu verwenden, nur Kleinbuchstaben und Unterstriche an Stelle von Leerzeichen.

Hinweis: Wenn Sie nicht über PHP und MySQL auf Ihrem system oder einem server ausgeführt werden können, empfehle ich das herunterladen einer stand-alone-Installation von Apache, PHP und MySQL. MAMP ist gut für Macs und WAMP ist gut für PCs.

Zunächst müssen wir die Datenbank erstellt, ich nenne es "nettuts_blog".

Anschließend legen wir unsere Tabellen; die erste wird "blog_posts".

"blog_posts" haben fünf Felder: "id", "Titel", "post", "author_id" und "date_posted". Für "id" machen wir es den primären Schlüssel und setzen Sie ihn auf auto-increment. Was wird dies tun, ist erzeugen unsere einzigartige id für uns. Jedes mal, wenn wir einen post wird es geben, es eine Nummer beginnend bei eins und bewegt sich für so viele posts haben wie wir.

Jetzt müssen wir auch festlegen der Variablen-Typ für jedes Feld. Die IDS werden in den Typ int, die Abkürzung für integer, da es nur eine Zahl und wir setzen die max Länge bis 11. Das Feld "title" gesetzt ist Typ varchar mit einer Länge von 255. Die "post" - Feld wird der Typ "text" und wir werden nicht eine max Länge, da die Beiträge können sehr lang sein. "author_id" werden die gleichen "id" - aber wir werden nicht als primary key oder auto-Inkrement, und wir werden "date_posted" in den Typ "Datum".

Unsere nächste Tabelle "Personen". Wir sind nicht nannte es "Autoren", weil die Straße hinunter, die wir vielleicht erstellen möchten, die Möglichkeit sich zu registrieren und Kommentare veröffentlichen und die Leute würden nicht als Autoren.

"Menschen" enthält fünf Felder: "id", "first_name", "last_name", "url" und "email".

"id" wird als ein int, primary key und auto increment, auf die gleiche Weise setzen wir die id von "blog_posts". "first_name", "last_name", "url" und "email" werden alle eingestellt werden, um den Typ varchar mit einer Länge von 255.

Unsere nächste Tabelle "tags" und wird für enthalten jetzt nur noch zwei Felder: "id" und "name". Die Straße runter wir könnten auch komplexere durch das hinzufügen einer Beschreibung, aber für dieses tutorial werden wir uns nicht. Wie wir zuvor "id" wird als int, primary key und auto increment. "name" vom Typ varchar und einer maximalen Länge von 255.

Und unsere Letzte Tabelle, "blog_post_tags", hat nur zwei Felder: "blog_post_id" und "tag_id". Sie werden beide gesetzt werden, um den Typ int mit einer Länge von 11. Wie Sie wahrscheinlich bemerkt, dass wir nicht einen Primärschlüssel für diese Tabelle. Dies ist, weil wir nie bekommen werden, Daten aus dieser Tabelle, es sei denn, wir Fragen für einen bestimmten blog-Beitrag oder alle Beiträge eines bestimmten tag-id.

Teil 2) Erstellen unsere Objekte in PHP

Bevor wir in unsere eigentliche PHP-code, den wir brauchen, um unsere Dateien und Ordner, für dieses tutorial haben wir unsere index.php in unserem root-Ordner dann ein Ordner enthält, wird unser CSS-Stylesheet, unsere JavaScript-Dateien, includes.php enthalten Sie Verweise auf unsere Objekte und MySQL Verbindung, und blogpost.php das halten wird unsere BlogPost-Objekt.

Nun, da wir unsere Datenbank eingestellt, wir müssen erstellen Sie die Objekte in PHP, um die Daten für uns. Objekte in der Programmierung ein Weg sind, an einem Strang zu ziehen unterschiedliche Attribute (Variablen) und Methoden, die beziehen sich alle auf die gleiche Sache. Objekte, die uns auch helfen, organisieren unsere Programme sehr viel mehr. Bevor wir springen in unsere Sachen für unseren blog, lasst uns einfach erstellen Sie ein einfaches Objekt, so dass wir können zeigen, was Sie sind, in ein mehr "real life" - Begriff.

Unser Objekt heißt "Fahrrad", nun gibt es zwei Arten von Dinge, die jedes Objekt hat Eigenschaften und Methoden. Eigenschaften des Objekts festlegen und Methoden sind, was das Objekt tut. Zum Beispiel unsere Rad-Objekts würde Eigenschaften wie Rad-Größe, Anzahl der Gänge, und vielleicht die frame-Größe. Für Methoden, die wir vielleicht so etwas wie "Pedal".

Nun gelangen Sie zurück auf unseren blog, wir brauchen nur ein Objekt heißt jetzt "Blog". Beitrag wird sechs Eigenschaften id, Titel, Beitrag, Autor, tags und Datum der Veröffentlichung. So können stellen Sie Sie in PHP.

Definieren Sie ein Objekt in PHP-wir definieren es als eine "Klasse". Eine Klasse ist die Struktur der einzelnen Objekte, oder, wie wikipedia es beschreibt, "In der objektorientierten Programmierung eine Klasse ist eine Programmiersprache Konstrukt, das verwendet wird, als ein bauplan, um Objekte zu erstellen. Dieser Plan enthält Attribute und Methoden, die die Objekte erstellt, alle teilen." (http://en.wikipedia.org/wiki/Concrete_class). Wir öffnen unsere blogpost.php Seite und definieren unser erstes Objekt.

Hinweis: In jedem Abschnitt des Tutorials, ich werde lassen Sie das öffnen und schließen PHP-tags; "" Sie müssen Sie am Anfang und Ende des Dokuments.

1	class BlogPost
2	{
3	}

In unserer Klasse müssen wir zuerst definieren unsere Eigenschaften. Um dies zu tun, müssen wir Variablen erstellen - aber mit "den öffentlichen" in-front von Ihnen. Nur eine kurze Notiz, wenn Sie mit PHP4, dann müssen Sie die Verwendung von "var" statt "public".

class BlogPost
{
  public $id;
	public $title;
	public $post;
	public $author;
	public $tags;
	public $datePosted;
}

Nun, wir haben alle unsere Eigenschaften definiert, wir definieren wollen, unsere erste Methode. Methoden werden ebenso beschrieben wie die Funktionen, aber der Hauptunterschied ist, dass eine Methode ist eine Funktion in einem Objekt. Also alle Methoden sind auch die Funktionen, aber nicht alle Funktionen sind Methoden.

Unsere erste Methode wird sein, was wird Konstruktor genannt; diese Methode wird automatisch aufgerufen, wenn wir eine neue Instanz der Beitrag Objekt.

Die gemeinsame Nutzung eines Konstruktors ist, so dass Sie können erstellen ein neues Objekt und legen Sie die Eigenschaften des Objekts schnell.

Also, was wir tun möchten, ist erstellen Sie eine neue Funktion namens __construct() und wir sind Los: in fünf Werte, die id, Titel, Beitrag, Autor-id, und das Datum geschrieben. Für jede variable name wir werden "in" vor dem Wort, so können wir sagen, in unseren Funktionen, welche Variablen übergeben werden und welche Variablen sind bereits vorhanden.

class BlogPost
{
	public $id;
	public $title;
	public $post;
	public $author;
	public $tags;
	public $datePosted;

	function __construct($inId, $inTitle, $inPost, $inAuthorId, $inDatePosted)
	{

	}
 }

Das problem hier ist, dass Sie mit diesem aktuellen code, jedes mal, wenn wir eine neue Instanz erstellen, der Beitrag müssen wir liefern alle diese Eigenschaften. Was aber, wenn wir wollen, um einen neuen blog-post und nicht definierten Variablen noch? Um dies zu umgehen, müssen wir "überlastung" die Argumente für unsere Funktion so, dass, wenn wir die Funktion aufrufen und don ' T pass in eines der Argumente, es wird sich automatisch legen Sie es auf den Standardwert.

1	function __construct($inId=null, $inTitle=null, $inPost=null, $inPostFull=null, $inAuthorId=null, $inDatePosted=null)
2	{
3	}

Wie Sie sehen können, alles, was wir tun, unsere Aufgabe jedes argument der Wert "null". Jetzt in unserem Konstruktor benötigen wir, um jede unserer Variablen zu unserer übergebenen Werte. Um dies zu tun möchten wir Sie auf das Objekt, das wir im Augenblick; Wir können dies tun mit dem keyword "this". Im Gegensatz zu vielen anderen Sprachen, um den Zugriff auf eine Eigenschaft in PHP, die Sie verwenden "->" wo in den meisten Sprachen (I. E. JavaScript, ASP.NET) verwenden Sie ".".

function __construct($inId=null, $inTitle=null, $inPost=null, $inPostFull=null, $inAuthorId=null, $inDatePosted=null)
{
	$this->id = $inId;
	$this->title = $inTitle;
	$this->post = $inPost;
}

Dies funktioniert mit id, Titel und post. Aber was ist mit den anderen? Für heute sind wir gehen zu müssen, um neu formatieren die Daten bekamen wir von MySQL mehr lesbar. Das ist leicht zu bewerkstelligen; Wir haben gerade explodieren (auch bekannt als splitting in anderen Programmiersprachen) und dann setzen Sie wieder zusammen. MySQL gibt es für uns in diesem format yyyy-mm-dd, also, wenn wir es explodieren mit "-" als Trennzeichen, das wir erhalten ein array holding drei Werte. Die ersten halten wird unser Jahr, das nächste wird unser Monat, und die letzten werden die Tag. Alles was wir jetzt tun, ist, setzen Sie Sie wieder zusammen in welchem format auch immer wir wollen. Ich werde mit mm/dd/yyyy.

1	$splitDate = explode("-", $inDatePosted);
2	$this->datePosted = $splitDate[1] . "/" . $splitDate[2] . "/" . $splitDate[0];

Für den Autor, alles, was wir tun müssen ist, Fragen Sie die Datenbank für die person mit der id des Autors-ID. Wir können dies tun mit einer grundlegenden MySQL-Abfrage.

1	$query = mysql_query("SELECT first_name, last_name FROM People WHERE id = " . $inAuthorId);
2	$row = mysql_fetch_assoc($query);
3	$this->author = $row["first_name"] . " " . $row["last_name"];

Left Join

Jetzt werden die tags etwas schwieriger. Wir werden darüber reden müssen, um die Datenbank, daher brauchen wir eine MySQL-Abfrage. Wir werden uns nicht sorgen über die Datenbank-Verbindung jetzt, dass definiert wird außerhalb dieser Klasse. Alles was wir jetzt haben, ist die blog-post-ID. Wir können vergleichen, dass die blog-Beiträge-tags in der blog_post_tags Tisch, aber dann werden wir nur wieder die tag-ID und eine weitere Abfrage, um die Informationen über den tag. Das ist nicht gut; Wir wollen effizient sein, so lasst es uns in nur einer Abfrage!

Um dies zu tun wir im Begriff sind zu tun, was man einen left join, das heißt, wir gehen, um auch wählen Sie Daten aus einer anderen Tabelle, aber nur, wenn es stimmt mit den Daten aus dem "linken" oder anderen unserer ausgewählten Daten. Also zuerst kommen wir alle tag-IDs, die im Zusammenhang mit unserer blog-post-ID in der blog_post_tags Tabelle.

1	$query = mysql_query("SELECT * FROM blog_post_tags WHERE blog_post_tags.blog_post_id = " . $inId);

Nun fügen wir unseren left join und sagen, unsere Frage, die wir nur die Daten in die tags-Tabelle:

1	$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);

So jetzt ist die Abfrage der Auswahl aus den tags und blog_posts_tags Tabellen, in denen zunächst blog_post_tags.blog_post_id gleich, die wir zur Verfügung gestellt, und dann kehrt auch die Informationen über die einzelnen Tags hat, tag_id, die in der gleichen Zeile von Daten, die das blog_post_id.

Nun wollen wir diese Daten verarbeiten in PHP mit einer einfachen while-Schleife. Wir werden auch zwei arrays erstellt, das halten wird, unsere Daten: eine für den tag-Namen, und die andere für die tag-id. Wir machen auch einen string zu halten alle unsere tags. Wir zuerst, setzen es um "Keine Tags", so dass wenn wir wieder keine Daten aus der MySQL-Abfrage zurück, wir haben keine tags, ansonsten wird dieser Wert überschrieben werden mit dem tag-Namen.

$postTags = "No Tags";
$tagArray = array();
$tagIDArray = array();
while($row = mysql_fetch_assoc($query)
{
	array_push($tagArray, $row["name"]);
	array_push($tagIDArray, $row["id"]);
}

Jetzt werden wir überprüfen, um sicherzustellen, dass, wenn das array hat eine Länge größer als null (wir wollen nicht, dass Sie all diese extra-code ein, wenn wir nicht müssen). Weiter, für jeden tag in unserem tag-Namen-array, wir gehen zu verketten einer Zeichenfolge von tags. Verwenden wir eine einfache if else-Anweisung.

if (sizeof($tagArray) > 0)
{
	foreach ($tagArray as $tag)
	{
		if ($postTags == "No Tags")
		{
			$postTags = $tag;
		}
		else
		{
			$postTags = $postTags . ", " . $tag;
		}
	}
}
$this->tags = $postTags;

Sie wahrscheinlich bemerkt, dass wir nicht die id-tag-arrays. Wir gehen zu lassen Sie allein für jetzt und kommen zurück zu Ihnen später. Wir wollen einfach nur unseren blog und läuft erste.

Der Letzte Schritt für unsere Klasse ist zu addieren, wenn-Anweisungen für jede Eigenschaft so ein, dass wenn wir übergeben, nichts, es wird nicht versucht, um das aktuelle Objekt die Eigenschaft zu gar nichts (dies wird einen Fehler verursachen). Hier ist der gesamte Beitrag Klasse mit der if-Anweisungen Hinzugefügt:

<?php

class BlogPost
{

public $id;
public $title;
public $post;
public $author;
public $tags;
public $datePosted;

function __construct($inId=null, $inTitle=null, $inPost=null, $inPostFull=null, $inAuthorId=null, $inDatePosted=null)
{
	if (!empty($inId))
	{
		$this->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 first_name, last_name FROM people WHERE id = " . $inAuthorId);
		$row = mysql_fetch_assoc($query);
		$this->author = $row["first_name"] . " " . $row["last_name"];
	}

	$postTags = "No 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 as $tag)
			{
				if ($postTags == "No Tags")
				{
					$postTags = $tag;
				}
				else
				{
					$postTags = $postTags . ", " . $tag;
				}
			}
		}
	}
	$this->tags = $postTags;
}

}

?>

Nun, dass unsere Objekt-Klasse abgeschlossen ist, werden die meisten das harte Zeug ist fertig! Alles was wir jetzt tun müssen, ist unsere Datenbank und die HTML-Darstellung unserer Beiträge!

Teil 3) das Abrufen der Daten Aus der MySQL und Anzeigen Mit PHP

Bevor wir etwas tun wir müssen unsere includes.php Datei um einen Verweis auf unsere Blog-Objekt und eine Verbindung zu unserer MySQL-Datenbank. Zunächst können auch unsere Objekt mit einem einfachen include-Anweisung:

1	include 'blogpost.php';

Jetzt können Sie unsere Datenbank-Verbindung:

$connection = mysql_connect("localhost", "username", "password") or die ("<p class='error'>Sorry, we were unable to connect to the database server.</p>");

$database = "nettuts_blog";

mysql_select_db($database, $connection) or die ("<p class='error'>Sorry, we were unable to connect to the database.</p>");

Als Nächstes benötigen wir das abrufen unserer blog-Beiträge aus der Datenbank. Um dies zu tun, werden wir eine-Funktion, kann bis zu zwei Argumente. Wir werden überlasten Sie beide; so können Sie rufen Sie die Funktion mit entweder 0, 1 oder 2 Argumente.

1	function GetBlogPosts($inId=null, $inTagId=null)
2	{
3
4	}

In unserer Funktion, die wir brauchen, um zu überprüfen, um zu sehen, welche Argumente übergeben wurden, und erstellen Sie unsere MySQL-query entsprechend.

function GetBlogPosts($inId=null, $inTagId =null)
{
	if (!empty($inId))
	{

	}
	else if (!empty($inTagId))
	{

	}
	else
	{

	}
}

Also, was wir hier tun, ist zu Fragen, ob jedes argument ist nicht leer, der Grund, warum wir die leere Funktion, statt nur dabei die standard -"! = null," Vergleich ist, da leer nicht nur überprüft, ob die variable null ist, aber wenn es leer ist (I. E. ""). Wir werden nun eine Abfrage schreiben, je nachdem, welche Variablen, die wir haben. Wenn wir den pass in einem blog-post ID, die wir wollen einfach nur, dass die einzelnen blog-post, wenn wir geben der Funktion einen inTagId wir wollen, dass alle posts mit diesem tag, und sonst nur wollen, dass alle blog-Beiträge 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 =" . $tagID . " ORDER BY blog_posts.id DESC");
}
else
{
	$query = mysql_query("SELECT * FROM blog_posts ORDER BY id DESC");
}

Der nächste Schritt ist die Aufbereitung der zurückgegebenen Daten von jedem Abfragen, erstellen Sie die Objekte und fügen Sie diese zu einem array zurück.

$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 die gesamte includes.php Datei-code:

<?php
include 'blogpost.php';

$connection = mysql_connect('localhost', 'username', 'password') or die ("<p class='error'>Sorry, we were unable to connect to the database server.</p>");
$database = "nettuts_blog";
mysql_select_db($database, $connection) or die ("<p class='error'>Sorry, we were unable to connect to the database.</p>");

function 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 bewegen wir uns auf die Darstellung unserer Daten, können unsere index.php Datei und eine einfache HTML-Seite. In unserem Körper schaffen wir eine division mit der id "main" enthalten wird unser blog. Geben wir unserem blog einen Titel und dann einen zweiten div in main aufgerufen wird, "Beiträge".

<div id="main">
	<h1>My Simple Blog</h1>
	<div id="blogPosts">

	</div>
</div>

In unserem Artikel, div, wir werden in einigen PHP, so dass wir können, zeigen unsere Beiträge. Zuerst werden wir auch unsere includes.php Datei und rufen Sie dann unsere GetBlogPosts Funktion ohne Argumente aus, um alle unsere blog-Beiträge und auf ein array mit dem Namen Beiträge.

<?php
include 'includes/includes.php';

$blogPosts = GetBlogPosts();
?>

Jetzt verwenden wir eine foreach-Schleife anzeigen unserer blog-Beiträge. Was für eine foreach-Schleife wird für uns jetzt ist, nimmt ein array und führt den code in der Schleife für jedes Element in dem array, können Sie auch eine normale for-Schleife, um dies zu erreichen, aber mit einer foreach-Schleife benötigt weniger code.

1	foreach ($blogPosts as $post)
2	{
3
4	}

Innerhalb der Schleife verwenden wir $post als das aktuelle array-Element, und da $Artikel, ist ein array von Post-Objekten können wir einfach "->" Zugriff auf jede Eigenschaft, die wir wollen. Lässt Anfang, nur echo den Titel des einzelnen blog-post auf unserer Seite und fügen Sie einfach ein - als ein Beispiel.

1	foreach ($blogPosts as $post)
2	{
3	echo $post->title . "<br/>";
4	}

Wenn wir gehen, um unsere Datenbank und legen Sie einige gefälschte Daten, dann öffnen index.php in einem browser, erhalten wir so etwas wie dieses:

Lassen Sie uns wirklich bauen unsere Beiträge in HTML. Jeder post wird eingewickelt in ein div mit einer Klasse der "post". Dann haben wir die post-Titel innerhalb eines h1-Tags und den eigentlichen Beitrag in einem - tag.

foreach ($blogPosts as $post)
{
	echo "<div class='post'>";
	echo "<h2>" . $post->title . "</h2>";
	echo "<p>" . $post->post . "</p>";
	echo "</div>";
}

Lassen Sie uns auch geben, jeder Beitrag eine Fußzeile, die auch den Autor des Beitrags, Datum der Veröffentlichung, und der post-tags. Wir werden alle diese Informationen innerhalb eines span-Tags mit der Klasse "footer".

foreach ($blogPosts as $post)
{
	echo "<div class='post'>";
	echo "<h1>" . $post->title . "</h1>";
	echo "<p>" . $post->post . "</h1>";
	  echo "<span class='footer'>Posted By: " . $post->author . " Posted On: " . $post->datePosted . " Tags: " . $post->tags . "</span>";
	echo "</div>";
}

Schauen wir uns nun an unsere index.php Datei erneut in einem browser:

Sieht aus wie alle seine arbeiten! Als Nächstes fügen wir einige styling.

Viel besser; Sie können diese online hier oder klicken Sie auf die große "demo" - buttons. Das war es für dieses tutorial. In einem späteren tutorial werden wir weitere Funktionen hinzuzufügen, um unseren blog, darunter auch einige nette AJAX-Funktionen!

Ich hoffe, Sie verstehen jetzt besser, wie objektorientierte Programmierung funktioniert. Auch wenn Sie am Ende tut die Mehrheit Ihrer Entwicklung mit einem framework, dessen sehr wichtig, um eine Kern-Verständnis der Grundlagen. Wenn Sie konkrete Fragen zu diesem tutorial, zögern Sie nicht, tweet me @benemills. Ich möchte einen besonderen Dank an James Padolsey für das helfen mich mit diesem Artikel.

Stay tuned für Teil 2!

Abonnieren Sie den NETTUTS RSS-Feed für mehr tägliche web-Entwicklung tuts und Artikel.

1	<?php
2
3	class BlogPost
4	{
5
6	public $id;
7	public $title;
8	public $post;
9	public $author;
10	public $tags;
11	public $datePosted;
12
13	function __construct($inId=null, $inTitle=null, $inPost=null, $inPostFull=null, $inAuthorId=null, $inDatePosted=null)
14	{
15	if (!empty($inId))
16	{
17	$this->id = $inId;
18	}
19	if (!empty($inTitle))
20	{
21	$this->title = $inTitle;
22	}
23	if (!empty($inPost))
24	{
25	$this->post = $inPost;
26	}
27
28	if (!empty($inDatePosted))
29	{
30	$splitDate = explode("-", $inDatePosted);
31	$this->datePosted = $splitDate[1] . "/" . $splitDate[2] . "/" . $splitDate[0];
32	}
33
34	if (!empty($inAuthorId))
35	{
36	$query = mysql_query("SELECT first_name, last_name FROM people WHERE id = " . $inAuthorId);
37	$row = mysql_fetch_assoc($query);
38	$this->author = $row["first_name"] . " " . $row["last_name"];
39	}
40
41	$postTags = "No Tags";
42	if (!empty($inId))
43	{
44	$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);
45	$tagArray = array();
46	$tagIDArray = array();
47	while($row = mysql_fetch_assoc($query))
48	{
49	array_push($tagArray, $row["name"]);
50	array_push($tagIDArray, $row["id"]);
51	}
52	if (sizeof($tagArray) > 0)
53	{
54	foreach ($tagArray as $tag)
55	{
56	if ($postTags == "No Tags")
57	{
58	$postTags = $tag;
59	}
60	else
61	{
62	$postTags = $postTags . ", " . $tag;
63	}
64	}
65	}
66	}
67	$this->tags = $postTags;
68	}
69
70	}
71
72	?>