Share
Under de senaste veckorna har NETTUTS lagt upp en hel del bra handledning om hur man kommer igång med PHP och MySQL för att skapa enkla webbapplikationer som en shoutbox. Idag kommer vi att ta vår kunskap om PHP och MySQL ett steg längre genom att skapa en enkel blogg. Medan det finns otaliga bra gratis bloggplattformar, är syftet med denna handledning inte att göra en "bättre" blogg utan att använda processen att göra en blogg för att lära sig om avancerad databasstrukturteknik och hur man använder data mer effektivt genom att använda objekt i PHP.
Enkla Blog Files.zip
benmillsdesigns.com/simpleblog/
För denna handledning antas det att du har viss grundläggande förståelse för PHP, MySQL, XHTML och senare jQuery / JavaScript.
Innan vi flyttar in i MySQL-klienten och börjar skapa våra bord, borde vi lägga ut vad vi vill ha i vår blogg. Den uppenbara sak som vi behöver hålla är blogginlägg, och i varje inlägg ska det innehålla en titel, inlägget, en författare och datumet det var upplagt.
Nu kan vi bara göra ett bord för att hålla den informationen, och troligen uppnå en grundläggande blogg, men med bara ett bord har vi inte lika mycket kontroll över våra data. Till exempel kan vi bara lagra författarens namn i samma tabell som blogginlägget, men vad gör vi om vi vill lagra författarens e-post? Säker! Vi lägger bara till ett annat fält till vårt bord skulle vara den uppenbara lösningen.
Problemet kommer upp när du är på väg, vill du ändra den författarens e-postadress. Nu måste du ändra det för varje enskilt blogginlägg som personen har skapat.
Så vad vi ska göra är att skapa ett separat bord som heter "People" och i det här lagrar vi all information vi behöver från författaren - till exempel e-postadresser, webbadresser, deras namn och ett unikt ID. Då kommer vi i vårt blogginlägg att peka på den person vi vill använda den personens unika ID. Detta id kallas en främmande nyckel och förhållandet mellan blogginställningsbordet och folketabellen kallas för ett till många förhållande.
En annan sak vi vill ha i vår blogg är en tagg för varje blogginlägg. Återigen vill vi göra vår databas effektiv så vi skapar ett separat bord för våra taggar. Vad gör vi nu? Ska vi skapa ett fält i bloggpostbordet som är en utländsk nyckel för vår tagg? Problemet med att använda ett en-till-ett-förhållande den här gången är ibland blogginlägg har mer än en tagg; så igen, vi kommer att använda ett ett till många förhållande. För att göra detta måste vi skapa en annan tabell som kallas något som "blog_post_tags" som kommer att hålla två främmande nycklar, en kommer att vara blogginläggets ID och den andra kommer att vara det tagg-ID som blogginlägget är associerat med. På så vis kan vi tilldela så många taggar som vi vill ha ett blogginlägg, men kan ändå redigera informationen om den specifika taggen över alla inlägg med en enkel MySQL-fråga.
Nu när vi har skisserat vad vi vill att vår databas ska se ut, låt oss skapa den. Jag använder PhpMyAdmin eftersom det är den mest använda MySQL-administratorklienten. Det finns några olika namngivningskonventioner du kan använda när du skapar din databas, tabell och fältnamn. Jag personligen gillar att använda alla små bokstäver och understreck i stället för mellanslag.
Obs! Om du inte har PHP och MySQL på ditt system eller en server som kan köra den, rekommenderar jag att du laddar ned en fristående installation av Apache, PHP och MySQL. MAMP är bra för Mac och WAMP är bra för datorer.
Först måste vi skapa vår databas, jag ska kalla det "nettuts_blog".
Därefter kommer vi att skapa våra bord; den första kommer att vara "blog_posts".
"blog_posts" kommer att ha fem fält: "id", "title", "post", "author_id" och "date_posted". För "id" ska vi göra den till den primära nyckeln och ställa in den för automatisk inkrement. Vad detta kommer att göra är att skapa vårt unika id för oss. Varje gång vi lägger till ett inlägg kommer det att ge det ett nummer som börjar vid ett och flyttas upp för så många inlägg som vi har.
Nu måste vi också ställa in variabelstypen för varje fält. Id kommer att ställas in för att skriva int, kort för heltal eftersom det bara kan vara ett tal och vi ställer in maxlängden till 11. Fältet "titel" kommer att ställas in för att skriva varchar med en max längd på 255. " posten "kommer att vara typ" text "och vi kommer inte ange en max längd eftersom inlägg kan vara mycket långa. "author_id" kommer att vara densamma som "id", men vi kommer inte ange det som vår primära nyckel eller har det automatisk inkrement och vi kommer att ange "date_posted" för att skriva "Date".
Vårt nästa bord kommer att vara "människor". Vi kallar inte det "författare" eftersom vi kanske vill skapa möjligheten att registrera och skicka kommentarer och att de inte skulle anses vara författare.
"människor" innehåller också fem fält: "id", "first_name", "last_name", "url" och "email".
"id" kommer att ställas in som en int, den primära nyckeln, och till automatisk inkrement, på samma sätt som vi anger id för "blog_posts". "first_name", "last_name", "url" och "email" kommer alla att ställas in för att skriva varchar med max längd 255.
Vårt nästa bord kommer att vara "tags" och innehåller för närvarande bara två fält: "id" och "namn". Nedför vägen kunde vi göra detta mer komplext genom att lägga till en beskrivning men för den här handledningen kommer vi inte att göra det. Som vi gjorde kommer "id" att ställas in som int, primärnyckel och automatisk inkrement. "namn" kommer att vara typ varchar och ha en max längd på 255.
Och vårt senaste bord, "blog_post_tags", har bara två fält: "blog_post_id" och "tag_id". De kommer båda att ställas in för att skriva int med en maximal längd av 11. Som du troligen märkte noterade vi inte en primär nyckel för den här tabellen. Det beror på att vi aldrig kommer att få data ut ur den här tabellen om vi inte ber om ett visst blogginlägg eller alla inlägg i ett specifikt tagg-id.
Innan vi börjar med vår faktiska PHP-kod måste vi skapa våra filer och mappar. För denna handledning kommer vi att ha vårt index.php i vår rotmapp, då innehåller en mapp som håller vårt CSS-stilark, våra JavaScript-filer, includes.php som kommer att innehålla referenser till våra objekt och MySQL-anslutning, och blogpost.php som håller vår bloggpost obejct.
Nu när vi har vår databasuppsättning behöver vi skapa objekten i PHP som hanterar data för oss. Objekt i programmering är ett sätt att dra samman olika attribut (som variabler) och metoder som alla relaterar till samma sak. Objekt hjälper oss också att organisera våra program mycket mer. Innan vi hoppar in i våra föremål för vår blogg, låt oss bara skapa ett enkelt objekt så att vi kan illustrera vad de är i en mer "verklig" term.
Vårt objekt kommer att kallas "Bike", nu finns det två typer av saker som varje objekt har, egenskaper och metoder. Egenskaper definierar objektet och metoder är vad objektet gör. Till exempel skulle vårt cykelobjekt ha egenskaper som hjulstorlek, antal växlar och kanske ramstorleken. För metoder kan vi ha något som "Pedal".
Nu för att flytta tillbaka till vår blogg behöver vi bara ett objekt för nu kallat "BlogPost". BlogPost har sex egenskaper, id, titel, inlägg, författare, taggar och datum publicerat. Så kan vi göra det i PHP.
För att definiera ett objekt i PHP definierar vi det som en "klass". En klass är strukturen för varje objekt, eller som wikipedia beskriver det: "I objektorienterad programmering är en klass en programmeringsspråkskonstruktion som används som en ritning för att skapa objekt. I denna ritning ingår attribut och metoder som de skapade objekten alla dela med sig." (Http://en.wikipedia.org/wiki/Concrete_class). Vi kommer att öppna vår bloggpost.php-sida och definiera vårt första objekt.
Obs! I varje avsnitt i handledningen kommer jag att lämna ut öppning och stängning av PHP-taggar; ""du måste inkludera dem i början och slutet av ditt dokument.
klass bloggpost
I vår klass behöver vi först definiera våra egenskaper. För att göra detta måste vi skapa variabler - men med "offentliga" framför dem. Bara en snabb notering, om du använder PHP4 måste du använda "var" istället för "offentliga".
klass BlogPost public $ id; offentlig $ title; offentlig $ post; offentlig $ författare; offentliga $ taggar; offentlig $ datePosted;
Nu när vi har definierat alla våra egenskaper vill vi definiera vår första metod. Metoder beskrivs också som funktioner, men huvudskillnaden är att en metod är en funktion inom ett objekt. Så alla metoder är också funktioner men inte alla funktioner är metoder.
Vår första metod kommer att vara det som kallas en konstruktör; Denna metod kallas automatiskt när vi gör en ny instans av BlogPost-objektet.
Den gemensamma användningen av en konstruktör är så att du kan skapa ett nytt objekt och snabbt ange egenskaperna för det objektet.
Så vad vi vill göra är att skapa en ny funktion som heter __construct () och vi kommer att gå vidare i fem värden, id, titel, post, författar-ID och datum publicerat. För varje variabelnamn kommer vi att sätta "in" före ordet så vi kan berätta inuti våra funktioner vilka variabler som skickas in och vilka variabler är redan närvarande.
klass BlogPost public $ id; offentlig $ title; offentlig $ post; offentlig $ författare; offentliga $ taggar; offentlig $ datePosted; funktion __construct ($ inId, $ inTitle, $ inPost, $ inAuthorId, $ inDatePosted)
Problemet här är att med den här nuvarande koden varje gång vi skapar en ny instans av BlogPost behöver vi tillhandahålla alla dessa egenskaper. Men vad händer om vi vill skapa ett nytt blogginlägg och har inte definierat dessa variabler än? För att hantera detta måste vi "överbelasta" argumenten för vår funktion så att om vi kallar funktionen och inte passerar i någon av argumenten, ställs den automatiskt till standardvärdet.
funktion __construct ($ inId = null, $ inTitle = null, $ inPost = null, $ inPostFull = null, $ inAuthorId = null, $ inDatePosted = null)
Som vi kan se är allt som vi gör för att uppnå vår uppgift satt varje argument till värdet "null". Nu inom vår konstruktör måste vi ställa in var och en av våra variabler till våra godkända värden. För att göra detta vill vi ställa dem till objektet vi är i just nu; Vi kan göra detta med "det här" sökordet. Till skillnad från många andra språk för att komma åt en egenskap i PHP använder du "->" där i de flesta språk (I.E. JavaScript, ASP.NET) du använder ".".
funktion __construct ($ inId = null, $ inTitle = null, $ inPost = null, $ inPostFull = null, $ inAuthorId = null, $ inDatePosted = null) $ this-> id = $ inId; $ this-> title = $ inTitle; $ this-> post = $ inPost;
Detta fungerar för id, titel och post. Men hur är det med våra andra? För datum måste vi reformatera de data vi fick från MySQL för att vara mer läsbar. Det är lätt att uppnå; Vi exploderar det bara (även känt som splittring i andra programmeringsspråk) och lägger det tillbaka ihop. MySQL ger oss det här formatet yyyy-mm-dd, så om vi exploderar det med "-" som vår separator får vi en array med tre värden. Den första kommer att hålla vårt år, nästa håller vår månad, och den sista blir dagen. Nu är allt vi gör sätta tillbaka dem i vilket format vi vill ha. Jag går med mm / dd / yyyy.
Accentsconagua
$ splitDate = explodera ("-", $ inDatePosted); $ this-> datePosted = $ splitDate [1]. "/". $ splitDate [2]. "/". $ SplitDate [0]; För författaren är allt vi behöver göra, fråga databasen för den person med ID för vår författar-ID. Vi kan göra det med en grundläggande MySQL-fråga.
$ query = mysql_query ("VÄLJ förnamn, efternamn FRÅN Människor WHERE id =". $ inAuthorId); $ row = mysql_fetch_assoc ($ query); $ this-> author = $ row ["first_name"]. "". $ Rad [ "efternamn"]; Nu kommer taggarna att bli lite svårare. Vi kommer att behöva prata med databasen, så vi måste skapa en MySQL-fråga. Vi kommer inte oroa oss för databasanslutningen just nu, som kommer att definieras utanför denna klass. Nu har vi bara bloggpostens ID. Vi kan jämföra det med blogginlägget taggar i vårt blogg_post_tags bord men då kommer vi bara att få tillbaka taggens ID och måste göra en ny fråga för att få information om taggen. Det är inte bra; Vi vill vara effektiva så låt oss göra det på bara en fråga!
För att göra detta ska vi göra vad som kallas ett vänsterförbund, det betyder att vi också väljer data från en annan tabell men endast när den matchar data från "vänster" eller vår andra valda data. Så först får vi bara alla tagg-ID som är kopplade till vårt blogginläggs ID i tabellen blog_post_tags.
$ query = mysql_query ("VÄLJ * FRÅN blog_post_tags WHERE blog_post_tags.blog_post_id =". $ inId); Låt oss nu lägga till vårt vänstra medlem och berätta för vår fråga, vi vill bara ha data i tabellen taggar:
$ query = mysql_query ("VÄLJ taggar. * FRÅN blog_post_tags VÄNSTER JOIN (taggar) ON (blog_post_tags.tag_id = tags.id) WHERE blog_post_tags.blog_post_id =". $ inId); Så nu väljer frågan allt från tabellerna taggar och blog_posts_tags där första blog_post_tags.blog_post_id är lika med den som vi tillhandahöll och returnerar sedan också informationen om varje tagg som har den taggen som ligger i samma rad av data som vår blog_post_id.
Nu vill vi bearbeta data i PHP med en enkel slinga. Vi ska också skapa två arrayer som håller våra data: en för taggenamn och den andra för taggen id. Vi kommer också att göra en sträng för att hålla alla våra taggar. Vi kommer först att ställa in det på "Inga etiketter" så att om vi inte returnerar några data från vår MySQL-fråga kommer det att returnera att vi inte har några taggar, annars kommer värdet att överskridas med taggen namnen.
$ postTags = "Inga Tags"; $ tagArray = array (); $ tagIDArray = array (); ($ row = mysql_fetch_assoc ($ query) array_push ($ tagArray, $ row ["name"]); array_push ($ tagIDArray, $ row ["id"]);
Nu kommer vi att kontrollera om arrayen har en längd större än noll (vi vill inte utföra all denna extra kod om vi inte behöver). Därefter kommer vi att sammanfoga en rad taggar för varje tagg i vårt tagnamn array. Vi kommer att använda ett enkelt eller annat uttalande.
om (sizeof ($ tagArray)> 0) foreach ($ tagArray as $ tag) om ($ postTags == "Inga Tags") $ postTags = $ tagg; annat $ postTags = $ postTags. ",". $ Tag; $ this-> tags = $ postTags;
Du märkte mest sannolikt att vi inte använde tagg-id-arraysna. Vi kommer att lämna dem ensamma för nu och komma tillbaka till dem senare. Vi vill bara få vår blogg igång först.
Det sista steget för vår klass är att lägga till om uttalanden för varje egendom så att om vi inte skickar in någonting, försöker det inte att ställa in det aktuella objektets egendom till något (det här kommer att orsaka ett fel). Här är hela BlogPost-klassen med om-förklaringarna tillagt:
id = $ inId; om (! tomt ($ inTitle)) $ this-> title = $ inTitle; om (! tomt ($ inPost)) $ this-> post = $ inPost; om (! tomt ($ inDatePosted)) $ splitDate = explodera ("-", $ inDatePosted); $ this-> datePosted = $ splitDate [1]. "/". $ splitDate [2]. "/". $ SplitDate [0]; om (! tomt ($ inAuthorId)) $ query = mysql_query ("VÄLJ förnamn, efternamn FRÅN personer WHERE id =". $ inAuthorId); $ row = mysql_fetch_assoc ($ query); $ this-> author = $ row ["first_name"]. "". $ Rad [ "efternamn"]; $ postTags = "Inga Tags"; om (! tomt ($ inId)) $ query = mysql_query ("VÄLJ taggar. * FRÅN blog_post_tags VÄNSTER GÅNG (taggar) ON (blog_post_tags.tag_id = tags.id) WHERE blog_post_tags.blog_post_id =". $ inId); $ tagArray = array (); $ tagIDArray = array (); medan ($ row = mysql_fetch_assoc ($ query)) array_push ($ tagArray, $ row ["name"]); array_push ($ tagIDArray, $ row ["id"]); om (sizeof ($ tagArray)> 0) foreach ($ tagArray som $ tagg) if ($ postTags == "Inga Tags") $ postTags = $ tagg; annat $ postTags = $ postTags. ",". $ Tag; $ this-> tags = $ postTags; ?> Nu när vår objektklass är färdig är de flesta av de hårda grejerna färdiga! Nu behöver vi bara konfigurera vår databasförbindelse och HTML för att visa våra inlägg!
Innan vi gör någonting behöver vi konfigurera vår include.php-fil för att hålla en referens till vårt bloggpostobjekt och ansluta till vår MySQL-databas. Först låt oss inkludera vårt objekt med ett enkelt inkludera uttalande:
inkludera "blogpost.php";
Nu kan vi lägga till vår databasanslutning:
$ connection = mysql_connect ("localhost", "användarnamn", "lösenord") eller dö ("Tyvärr kunde vi inte ansluta till databasservern.
"$; $ database =" netuts_blog "; mysql_select_db ($ databas, $ anslutning) eller dö ("Tyvärr kunde vi inte ansluta till databasen.
"); Därefter måste vi hämta våra blogginlägg från databasen. För att göra detta ska vi göra en funktion som kan ta upp till två argument. Vi kommer att överbelasta dem båda; så du kan ringa funktionen med antingen 0, 1 eller 2 argument.
funktion GetBlogPosts ($ inId = null, $ inTagId = null)
Inom vår funktion måste vi kolla för att se vilka argument som skickades in och skapa vår MySQL-fråga i enlighet därmed.
funktion (Get Inlog
Så vad gör vi här är att fråga om varje argument inte är tomt, beror anledningen till att vi använder den tomma funktionen istället för att bara göra standardvärdet "! = Null" jämförelsen, eftersom det inte bara är att tömmer inte bara om variabeln är null, men om den tom också (IE ""). Nu ska vi skriva en fråga beroende på vilka variabler vi har. Om vi skickar in ett blogginlägg, vill vi bara ha det enda blogginlägget, om vi ger funktionen en inTagId vill vi ha alla inlägg som har den taggen och annars vill vi bara ha alla blogginlägg i vår databas.
om ! tom ($ inId)) $ query = mysql_query ("VÄLJ * FRÅN blog_posts WHERE id =". $ inId. "BESTÄLL AV ID DESC"); annars om (! tomt ($ inTagId)) $ query = mysql_query ("VÄLJ blog_posts. * FRÅN blog_post_tags VÄNSTER JOIN (blog_posts) ON (blog_post_tags.postID = blog_posts.id) VAR blog_post_tags.tagID =". $ tagID. " BESTÄLL BY blog_posts.id DESC "); else $ query = mysql_query ("VÄLJ * FRÅN blog_posts ORDER BY id DESC"); Nästa steg är att bearbeta data som returneras från varje fråga, skapa objekten och lägg sedan till dem i en array för att återvända.
$ postArray = array (); ($ row = mysql_fetch_assoc ($ query)) $ myPost = ny BlogPost ($ rad ["id"], $ rad ['title'], $ row ['post'], $ row ['postfull'] $ row ['firstname']. "". $ rad ['efternamn'], $ rad ['datumpostat']); array_push ($ postArray, $ myPost); returnera $ postArray;
Här är hela include.php-filens kod:
Tyvärr kunde vi inte ansluta till databasservern."$; $ database =" netuts_blog "; mysql_select_db ($ databas, $ anslutning) eller dö ("Tyvärr kunde vi inte ansluta till databasen.
"), funktion GetBlogPosts ($ inId = null, $ inTagId = null) if (! empty ($ inId)) $ query = mysql_query (" VÄLJ * FRÅN blog_posts WHERE id = ". $ inId." BESTÄLL AV ID DESC "); annars om (! tomt ($ inTagId)) $ query = mysql_query (" VÄLJ blog_posts. * FRÅN blog_post_tags VÄNSTER JOIN (blog_posts) ON (blog_post_tags.postID = blog_posts.id) VAR blog_post_tags.tagID = ". tagged. "ORDER BY blog_posts.id DESC"); annars $ query = mysql_query ("VÄLJ * FRÅN blog_posts ORDER BY id DESC"); $ postArray = array (); medan ($ row = mysql_fetch_assoc ($ query) ) $ myPost = ny bloggpost ($ rad ["id"], $ rad ['titel'], $ rad ['post'], $ rad ['postfull'], $ rad ["author_id"], $ rad ['dateposted']); array_push ($ postArray, $ myPost); returnera $ postArray;?> Nu kan vi gå vidare för att visa vår data, låter öppna vår index.php-fil och skapa en grundläggande HTML-sida. Inuti vår kropp skapar vi en uppdelning med ett huvudnamn som innehåller vår blogg. Vi kommer att ge vår blogg en titel och sedan ha en andra div inuti huvud som kommer att kallas "blogPosts".
Min enkla blogg
Inne i vår bloggPosts div lägger vi in några PHP så att vi kan visa våra inlägg. Först ska vi inkludera vår include.php-fil och sedan ringa vår GetBlogPosts-funktion utan argument för att få alla våra blogginlägg och ställa in det till en grupp som heter blogPosts.
Nu kommer vi att använda en foreach loop för att visa våra blogginlägg. Vad en slinga gör för oss just nu tar en matris och kör koden i slingan för varje objekt i matrisen. Du kan också använda en normal för slinga för att uppnå detta, men en slinga kräver mindre kod.
foreach ($ blogPosts as $ post)
Inuti slingan använder vi $ post som det aktuella arrayobjektet och eftersom $ blogPosts är en rad BlogPost-objekt kan vi helt enkelt använda "->" för att få tillgång till varje egendom som vi vill ha. Låt oss börja med att bara kopiera titeln på varje blogginlägg till vår sida och bara lägga till en
- som ett exempel.
foreach ($ blogPosts as $ post) echo $ post-> title. "
";
Om vi går till vår databas och lägger in några falska data öppnar du index.php i en webbläsare, så får vi något sådant:
Låt oss verkligen bygga våra inlägg i HTML. Varje inlägg kommer att vara inslaget i en div med en klass av "post". Då kommer vi att ha posten titeln inuti en h1-tagg och den faktiska posten inuti a
märka.
foreach ($ blogPosts as $ post) echo ""echo"";". $ post-> titel."
"echo"". $ post-> post."
"echo"
Låt oss också ge varje inlägg en sidfot som inkluderar postens författare, datum som postat och postens taggar. Vi lägger all denna information inom en span-tagg med en klass "footer".
foreach ($ blogPosts as $ post) echo ""echo"";". $ post-> titel."
"echo"". $ post-> post.""echo"Publicerad av: ". $ Post-> author." Skickat på: ". $ Post-> datePosted." Taggar: ". $ Post-> taggar.""echo"
Låt oss nu titta på vår index.php-fil igen i en webbläsare:
Ser ut som det är allt som fungerar! Låt oss sedan lägga till lite styling.
Mycket bättre; Du kan se det här online här eller klicka på de stora "demo" -knapparna. Det är det för denna handledning. I en efterföljande handledning lägger vi till mer funktionalitet i vår blogg, inklusive en del fina AJAX-funktioner!
Jag hoppas att du nu har en bättre förståelse för hur objektorienterad programmering fungerar. Även om du slutar göra majoriteten av din utveckling med hjälp av en ram, är det väldigt viktigt att ha en grundläggande förståelse för grunden. Om du har några specifika frågor om denna handledning, tveka inte att tweet mig @ benemills. Jag skulle vilja ge ett särskilt tack till James Padolsey för att hjälpa mig med den här artikeln.
Håll dig klar för del 2!
