Share
Au cours des dernières semaines, NETTUTS a publié plusieurs excellents tutoriels expliquant comment commencer à utiliser PHP et MySQL pour créer des applications Web simples, telles que des boîtes de dialogue. Aujourd'hui, nous allons approfondir nos connaissances en PHP et MySQL en créant un simple blog. Bien qu'il existe d'innombrables excellentes plates-formes de blogues gratuites, le but de ce didacticiel n'est pas de créer un "meilleur" blog, mais d'utiliser le processus de création d'un blog pour en savoir plus sur les techniques avancées de structure de base de données et sur la manière d'utiliser les données plus efficacement. PHP.
Simple Blog Files.zip
benmillsdesigns.com/simpleblog/
Pour ce tutoriel, on suppose que vous maîtrisez les bases de PHP, MySQL, XHTML et, plus tard, jQuery / JavaScript..
Avant de passer à notre client MySQL et de commencer à créer nos tables, nous devrions définir ce que nous voulons dans notre blog. La chose la plus évidente à faire est de publier des articles de blog. Dans chaque message, il doit contenir un titre, le message, un auteur et la date de publication..
Nous pourrions maintenant créer une seule table pour conserver ces informations et probablement créer un blog de base, mais avec une seule table, nous n'aurons pas autant de contrôle sur nos données. Par exemple, nous pourrions simplement stocker le nom de l'auteur dans le même tableau que celui de l'article de blog, mais que se passe-t-il si nous souhaitons également stocker le courrier électronique de l'auteur? Sûr! Nous venons d'ajouter un autre champ à notre table serait la solution évidente.
Le problème survient lorsque vous souhaitez modifier l’adresse électronique de cet auteur. Maintenant, vous devez le changer pour chaque article de blog créé par cette personne..
Nous allons donc créer un tableau séparé appelé "Personnes" dans lequel nous allons stocker toutes les informations dont l'auteur a besoin, telles que des courriels, des URL, leur nom et un identifiant unique. Ensuite, dans notre tableau de publication sur le blog, nous indiquerons la personne que vous souhaitez utiliser à l'aide de son identifiant unique. Cet identifiant est appelé clé étrangère et la relation entre la table de publication de blog et la table de personnes s'appelle une relation un-à-plusieurs..
Une autre chose que nous voulons dans notre blog est un tag pour chaque article de blog. Encore une fois, nous voulons rendre notre base de données efficace afin de créer un tableau séparé pour nos balises. Maintenant que faisons-nous? Devrions-nous créer un champ dans la table des articles de blog qui soit une clé étrangère pour notre tag? Le problème de l’utilisation d’une relation un à un cette fois-ci est que parfois les articles de blog ont plus d’un tag. Encore une fois, nous allons utiliser une relation un-à-plusieurs. Pour ce faire, nous devons créer une autre table appelée "blog_post_tags" qui contiendra deux clés étrangères, l’un correspondant à l’ID de la publication de blog et l’autre à l’ID de balise associé. De cette façon, nous pouvons attribuer autant de balises que nécessaire à un article de blog, mais nous pouvons toujours modifier les informations relatives à cette balise spécifique dans toutes les publications à l'aide d'une simple requête MySQL.
Maintenant que nous avons défini la structure de notre base de données, créons-la. J'utiliserai PhpMyAdmin car c'est le client administrateur MySQL le plus utilisé. Il existe différentes conventions de dénomination que vous pouvez utiliser lors de la création de noms de bases de données, de tables et de champs. Personnellement, j'aime bien utiliser toutes les minuscules et les soulignés à la place des espaces.
Remarque: Si votre système ne dispose pas de PHP et de MySQL, ni d'un serveur capable de l'exécuter, je vous recommande de télécharger une installation autonome d'Apache, PHP et MySQL. MAMP est bon pour les Mac et WAMP est bon pour les PC.
Nous devons d'abord créer notre base de données, je vais l'appeler "nettuts_blog".
Ensuite, nous allons créer nos tables. le premier sera "blog_posts".
"blog_posts" aura cinq champs: "id", "titre", "post", "author_id" et "date_posted". Pour "id", nous allons en faire la clé primaire et la définir pour l'incrémentation automatique. Ce que cela va faire, c'est générer notre identifiant unique pour nous. Chaque fois que nous ajoutons un article, il lui attribue un numéro commençant à un et augmentant pour autant d'articles que nous avons..
Maintenant, nous devons également définir le type de variable pour chaque champ. L'identifiant sera défini sur type int, abréviation de nombre entier, car il ne peut s'agir que d'un nombre et nous allons définir la longueur maximale sur 11. Le champ "titre" sera défini sur le type varchar avec une longueur maximale de 255. Le " Le champ "post" sera de type "texte" et nous ne définirons pas de longueur maximale, car les messages peuvent être très longs. "author_id" sera identique à "id" mais nous ne le définirons pas comme notre clé primaire ni l'incrémenterons automatiquement, et nous définirons "date_posted" pour taper "Date".
Notre prochaine table sera "les gens". Nous n’appelons pas cela des "auteurs", car nous pourrions éventuellement souhaiter créer la possibilité de s’inscrire et de publier des commentaires. Ces personnes ne seraient pas considérées comme des auteurs..
"personnes" contiendra également cinq champs: "id", "prénom_nom", "dernier nom", "url" et "email".
"id" sera défini comme un int, la clé primaire, et à incrémenter automatiquement, de la même manière que nous définissons l'identifiant de "blog_posts". "first_name", "last_name", "url" et "email" seront tous configurés pour taper varchar avec une longueur maximale de 255.
Notre prochaine table sera "tags" et ne contiendra pour l'instant que deux champs: "id" et "nom". Plus tard, nous pourrions rendre ceci plus complexe en ajoutant une description, mais pour ce tutoriel, nous ne le ferons pas. Comme nous l'avons déjà fait, "id" sera défini comme int, clé primaire et incrémentation automatique. "name" sera de type varchar et aura une longueur maximale de 255.
Et notre dernière table, "blog_post_tags", n'aura que deux champs: "blog_post_id" et "tag_id". Ils seront tous deux configurés pour taper int avec une longueur maximale de 11. Comme vous l'avez sans doute remarqué, nous n'avons pas défini de clé primaire pour cette table. En effet, nous n'obtiendrons jamais de données de cette table que si nous demandons un article de blog spécifique ou tous les articles d'un identifiant de tag spécifique..
Avant de commencer notre code PHP actuel, nous devons créer nos fichiers et dossiers. Pour ce tutoriel, nous aurons notre index.php dans notre dossier racine, puis un dossier includes contenant notre feuille de style CSS, nos fichiers JavaScript, includes.php. qui contiendra des références à nos objets et à la connexion MySQL, et blogpost.php qui contiendra notre objet BlogPost.
Maintenant que notre base de données est définie, nous devons créer les objets en PHP qui gèreront les données pour nous. Les objets en programmation sont un moyen de rassembler différents attributs (en tant que variables) et méthodes qui se rapportent tous à la même chose. Les objets nous aident également à organiser nos programmes beaucoup plus. Avant de nous lancer dans les objets de notre blog, créons simplement un objet simple afin de pouvoir illustrer ce qu’ils sont dans un terme plus "réel".
Notre objet s’appellera "Vélo", il existe maintenant deux types de propriétés, propriétés et méthodes. Les propriétés définissent l'objet et les méthodes sont ce que l'objet fait. Par exemple, notre objet Bike aurait des propriétés telles que la taille de la roue, le nombre d'engrenages et peut-être la taille du cadre. Pour les méthodes, nous pourrions avoir quelque chose comme "Pedal".
Maintenant, pour revenir à notre blog, nous n'avons besoin que d'un seul objet appelé "BlogPost". BlogPost aura six propriétés, id, titre, publication, auteur, tags et date de publication. Alors faisons en PHP.
Pour définir un objet en PHP, nous le définissons comme une "classe". Une classe est la structure de chaque objet, ou comme le décrit wikipedia, "Dans la programmation orientée objet, une classe est une construction de langage de programmation utilisée comme un schéma directeur pour créer des objets. Ce schéma comprend des attributs et des méthodes qui partager." (http://en.wikipedia.org/wiki/Concrete_class). Nous allons ouvrir notre page blogpost.php et définir notre premier objet.
Note: Dans chaque section du tutoriel, je vais laisser de côté les balises PHP d'ouverture et de fermeture; ""vous devrez les inclure au début et à la fin de votre document.
classe BlogPost
Dans notre classe, nous devons d’abord définir nos propriétés. Pour ce faire, nous devons créer des variables - mais avec "public" devant elles. Juste une petite note, si vous utilisez PHP4, vous devrez utiliser "var" au lieu de "public".
classe BlogPost public $ id; public $ title; public $ post; public $ author; balises publiques $; public $ datePosted;
Maintenant que toutes nos propriétés sont définies, nous voulons définir notre première méthode. Les méthodes sont également décrites comme des fonctions, mais la principale différence est qu'une méthode est une fonction dans un objet. Donc toutes les méthodes sont aussi des fonctions mais toutes les fonctions ne sont pas des méthodes.
Notre première méthode sera ce que l’on appelle un constructeur; cette méthode est automatiquement appelée chaque fois que nous créons une nouvelle instance de l'objet BlogPost.
L'utilisation courante d'un constructeur est que vous pouvez créer un nouvel objet et définir rapidement les propriétés de cet objet..
Donc, ce que nous voulons faire est de créer une nouvelle fonction appelée __construct () et nous allons passer en cinq valeurs, id, titre, publication, identifiant d'auteur et date de publication. Pour chaque nom de variable, nous allons mettre "in" avant le mot afin de pouvoir indiquer à l'intérieur de nos fonctions quelles variables sont passées et quelles variables sont déjà présentes.
classe BlogPost public $ id; public $ title; public $ post; public $ author; balises publiques $; public $ datePosted; function __construct ($ inId, $ inTitle, $ inPost, $ inAuthorId, $ inDatePosted)
Le problème ici est que, avec ce code actuel, chaque fois que nous créons une nouvelle instance de BlogPost, nous devons fournir toutes ces propriétés. Mais que se passe-t-il si nous voulons créer un nouveau blog et n’avons pas encore défini ces variables? Pour gérer cela, nous devons "surcharger" les arguments de notre fonction. Ainsi, si nous appelons la fonction et ne transmettons aucun des arguments, elle sera automatiquement définie sur la valeur par défaut..
function __construct ($ inId = null, $ inTitle = null, $ inPost = null, $ inPostFull = null, $ inAuthorId = null, $ inDatePosted = null)
Comme vous pouvez le constater, tout ce que nous faisons pour accomplir notre tâche consiste à attribuer à chaque argument la valeur "null". Maintenant, dans notre constructeur, nous devons définir chacune de nos variables sur nos valeurs passées. Pour ce faire, nous voulons les définir sur l'objet dans lequel nous nous trouvons en ce moment. Nous pouvons le faire avec le mot-clé "this". Contrairement à beaucoup d'autres langages, pour accéder à une propriété en PHP, vous utilisez "->", mais dans la plupart des langages (JavaScript, ASP.NET), vous utilisez ".".
function __construct ($ inId = null, $ inTitle = null, $ inPost = null, $ inPostFull = null, $ inAuthorId = null, $ inDatePosted = null) $ this-> id = $ inId; $ this-> title = $ inTitle; $ this-> post = $ inPost;
Cela fonctionne pour l'identifiant, le titre et l'article. Mais qu'en est-il de nos autres? Pour la date, nous allons avoir besoin de reformater les données que nous avons obtenues de MySQL pour être plus lisibles. C'est facilement accompli. Nous venons de l'exploser (également appelé division dans d'autres langages de programmation), puis de le reconstituer. MySQL nous le donne dans ce format aaaa-mm-jj, donc si nous l'explosons en utilisant "-" comme séparateur, nous obtiendrons un tableau contenant trois valeurs. Le premier tiendra notre année, le suivant notre mois et le dernier sera le jour. À présent, tout ce que nous faisons est de les rassembler dans le format de notre choix. Je vais avec mm / jj / aaaa.
Accentsconagua
$ splitDate = explode ("-", $ inDatePosted); $ this-> datePosted = $ splitDate [1]. "/". $ splitDate [2]. "/". $ splitDate [0]; Pour l'auteur, tout ce que nous avons à faire est de demander à la base de données la personne portant l'identifiant de notre identifiant d'auteur. Nous pouvons le faire avec une requête MySQL de base.
$ query = mysql_query ("SELECT nom, dernier nom FROM Personnes WHERE id =". $ inAuthorId); $ row = mysql_fetch_assoc ($ query); $ this-> author = $ row ["first_name"]. "". $ row ["last_name"]; Maintenant, les balises seront légèrement plus difficiles. Nous allons avoir besoin de parler à la base de données, nous devons donc créer une requête MySQL. Nous ne nous préoccuperons pas de la connexion à la base de données pour le moment, elle sera définie en dehors de cette classe. Maintenant, tout ce que nous avons, c'est l'identifiant de l'article. Nous pouvons comparer cela aux balises blog posts de notre table blog_post_tags, mais nous ne récupérerons alors que l'ID de la balise et nous devrons effectuer une autre requête pour obtenir les informations sur la balise. Ce n'est pas bon; Nous voulons être efficaces alors faisons-le en une seule requête!
Pour ce faire, nous allons faire ce qu'on appelle une jointure gauche, cela signifie que nous allons également sélectionner les données d'une autre table, mais uniquement lorsqu'elles correspondent aux données de la "gauche" ou de nos autres données sélectionnées. Commençons par obtenir tous les identifiants de balises associés à l'identifiant de notre publication dans la table blog_post_tags..
$ query = mysql_query ("SELECT * FROM blog_post_tags WHERE blog_post_tags.blog_post_id =". $ inId); Ajoutons maintenant notre jointure gauche et disons à notre requête que nous ne voulons que les données de la table des balises:
$ 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); Alors maintenant, la requête sélectionne tout dans les tables de tags et blog_posts_tags où, d'abord blog_post_tags.blog_post_id est égal à celui que nous avons fourni et renvoie également les informations sur chaque balise contenant ce tag_id qui se trouve dans la même ligne de données que notre blog_post_id.
Nous voulons maintenant traiter ces données en PHP avec une simple boucle while. Nous allons également créer deux tableaux qui contiendront nos données: une pour le nom de la balise et l'autre pour l'id de la balise. Nous allons également créer une chaîne pour contenir toutes nos balises. Nous allons d’abord définir le paramètre "No Tags" afin que, si nous ne renvoyons aucune donnée de notre requête MySQL, il nous indiquera que nous n’avons pas de tags, sinon cette valeur sera remplacée par les noms de tags..
$ postTags = "Pas de balises"; $ tagArray = array (); $ tagIDArray = array (); while ($ row = mysql_fetch_assoc ($ query) array_push ($ tagArray, $ row ["name"]); array_push ($ tagIDArray, $ row ["id"]);
Nous allons maintenant vérifier si la longueur du tableau est supérieure à zéro (nous ne voulons pas exécuter tout ce code supplémentaire si nous n’avons pas à le faire). Ensuite, pour chaque balise de notre tableau de noms de balises, nous allons concaténer une chaîne de balises. Nous allons utiliser une simple déclaration if else.
if (sizeof ($ tagArray)> 0) foreach ($ tagArray as $ tag) if ($ postTags == "Pas de balises") $ postTags = $ tag; else $ postTags = $ postTags. ",". balise $; $ this-> tags = $ postTags;
Vous avez probablement remarqué que nous n'avons pas utilisé les tableaux d'identificateurs de balises. Nous allons laisser ceux-là seuls pour le moment et y revenir plus tard. Nous voulons juste que notre blog soit opérationnel en premier.
La dernière étape pour notre classe consiste à ajouter des instructions if pour chaque propriété, de sorte que si nous ne transmettons rien, elle n'essaiera pas de définir la propriété de l'objet actuel sur rien (cela provoquera une erreur). Voici l'intégralité de la classe BlogPost avec les instructions if ajoutées:
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 nom, dernier nom FROM personnes WHERE id =". $ inAuthorId); $ row = mysql_fetch_assoc ($ query); $ this-> author = $ row ["first_name"]. "". $ row ["last_name"]; $ postTags = "Pas de balises"; 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 == "Pas de tags") $ postTags = $ tag; else $ postTags = $ postTags. ",". balise $; $ this-> tags = $ postTags; ?> Maintenant que notre classe d'objets est terminée, l'essentiel du travail est terminé! Il ne nous reste plus qu'à configurer notre connexion à la base de données et le code HTML pour afficher nos publications.!
Avant de faire quoi que ce soit, nous devons configurer notre fichier includes.php pour contenir une référence à notre objet BlogPost et vous connecter à notre base de données MySQL. Commençons par inclure notre objet avec une simple instruction include:
inclure 'blogpost.php';
Ajoutons maintenant notre connexion à la base de données:
$ connection = mysql_connect ("localhost", "nom d'utilisateur", "mot de passe") ou die ("Désolé, impossible de nous connecter au serveur de base de données..
"); $ database =" nettuts_blog "; mysql_select_db ($ database, $ connection) ou die ("Désolé, impossible de nous connecter à la base de données..
"); Ensuite, nous devons extraire nos articles de blog de la base de données. Pour ce faire, nous allons créer une fonction pouvant prendre jusqu'à deux arguments. Nous allons surcharger les deux; vous pouvez donc appeler la fonction avec 0, 1 ou 2 arguments.
fonction GetBlogPosts ($ inId = null, $ inTagId = null)
Dans notre fonction, nous devons vérifier quels arguments ont été passés et créer notre requête MySQL en conséquence..
fonction GetBlogPosts ($ inId = null, $ inTagId = null) if (! empty ($ inId)) else if (! empty ($ inTagId)) autre
Nous demandons donc si chaque argument n'est pas vide. La raison pour laquelle nous utilisons la fonction vide au lieu de simplement effectuer la comparaison standard "! = Null" est parce que vide vérifie non seulement si la variable est null, mais vide également (IE ""). Nous allons maintenant écrire une requête en fonction des variables que nous avons. Si nous transmettons un identifiant de publication de blog, nous ne voulons que cette publication de blog. Si nous donnons à la fonction un inTagId, nous souhaitons afficher tous les publications portant cette balise, sinon nous ne voulons que toutes les publications de blog de notre base.
if (! empty ($ inId)) $ requête = 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_post_tags.postID = blog_posts.id) WHERE blog_post_tags.tags.tagIDt", $ tagID. " ORDER BY blog_posts.id DESC "); else $ query = mysql_query ("SELECT * FROM blog_posts ORDER BY id DESC"); L'étape suivante consiste à traiter les données renvoyées par chaque requête, à créer les objets, puis à les ajouter à un tableau pour les renvoyer..
$ postArray = array (); while ($ row = mysql_fetch_assoc ($ query)) $ myPost = new BlogPost ($ row ["id"], $ row ['title'], $ row ['post'], $ row ['postfull'], $ row ['prenom']. "". $ row ["nom"], $ row ["dateposted"]); array_push ($ postArray, $ myPost); return $ postArray;
Voici le code complet du fichier includes.php:
Désolé, impossible de nous connecter au serveur de base de données.."); $ database =" nettuts_blog "; mysql_select_db ($ database, $ connection) ou die ("Désolé, impossible de nous connecter à la base de données..
"); function GetBlogPosts ($ inId = null, $ inTagId = null) if (! empty ($ inId)) $ query = mysql_query (" SELECT * DE blog_posts WHERE id = ". $ inId." ORDER BY id id "); 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.tagIDt ", $. tagID. "ORDER BY blog_posts.id DESC"); else $ query = mysql_query ("SELECT * FROM blog_posts ORDER BY id DESC"); $ postArray = array (); tandis que ($ 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;?> Nous pouvons maintenant afficher nos données, ouvrir notre fichier index.php et configurer une page HTML de base. Dans notre corps, nous allons créer une division avec un identifiant de "principal" qui contiendra notre blog. Nous donnerons un titre à notre blog puis nous aurons une deuxième div à l’intérieur de la page principale appelée "blogPosts".
Mon blog simple
Dans notre blogPosts div, nous allons mettre un peu de PHP pour pouvoir afficher nos articles. Nous allons d’abord inclure notre fichier includes.php, puis appeler notre fonction GetBlogPosts sans argument pour obtenir tous nos articles de blog et définir ce dernier dans un tableau appelé blogPosts..
Nous allons maintenant utiliser une boucle foreach pour afficher nos articles de blog. Ce qu'une boucle foreach fait pour nous maintenant, prend un tableau et exécute le code de la boucle pour chaque élément du tableau. Vous pouvez également utiliser une boucle for normale pour y parvenir, mais une boucle foreach nécessite moins de code..
foreach ($ blogPosts as $ post)
Dans la boucle, nous utilisons $ post en tant qu'élément de tableau actuel et, puisque $ blogPosts est un tableau d'objets BlogPost, nous pouvons simplement utiliser "->" pour accéder à chaque propriété souhaitée. Commençons par rappeler simplement le titre de chaque article de blog sur notre page et ajoutons simplement un
- par exemple.
foreach ($ blogPosts as $ post) echo $ post-> titre. "
";
Si nous allons dans notre base de données et y insérons de fausses données, puis ouvrons index.php dans un navigateur, nous obtiendrons quelque chose comme ceci:
Construisons vraiment nos articles en HTML. Chaque message sera emballé dans une div avec une classe de "post". Ensuite, nous aurons le titre du message dans une balise h1 et le message réel dans un
étiquette.
foreach ($ blogPosts as $ post) echo ""; écho "";". $ post-> titre."
"; écho "". $ post-> post."
"; écho "
Attribuons également à chaque article un pied de page contenant l'auteur, la date de publication et les balises de l'article. Nous allons mettre toutes ces informations dans une balise span avec une classe "footer".
foreach ($ blogPosts as $ post) echo ""; écho "";". $ post-> titre."
"; écho "". $ post-> post.""; écho "Publié par: ". $ Post-> auteur." Publié le: ". $ Post-> datePosté." Tags: ". $ Post-> tags.""; écho "
Examinons maintenant notre fichier index.php dans un navigateur:
On dirait que tout fonctionne! Ensuite, ajoutons du style.
Beaucoup mieux; vous pouvez voir ceci en ligne ici ou cliquer sur les gros boutons "démo". C'est pour ce tutoriel. Dans un prochain tutoriel, nous ajouterons plus de fonctionnalités à notre blog, y compris quelques fonctionnalités intéressantes AJAX.!
J'espère que vous comprenez mieux maintenant comment fonctionne la programmation orientée objet. Même si vous finissez par développer la majorité de votre développement en utilisant un cadre, il est très important d’avoir une compréhension de base des principes fondamentaux. Si vous avez des questions spécifiques sur ce tutoriel, n'hésitez pas à me tweeter @benemills. Je voudrais remercier tout particulièrement James Padolsey pour son aide dans cet article..
Restez à l'écoute pour la partie 2!
