Share
I løpet av de siste ukene har NETTUTS lagt ut mange gode opplæringsprogrammer om hvordan du kommer i gang med å bruke PHP og MySQL for å lage enkle webapplikasjoner som en shoutbox. I dag skal vi ta vår kunnskap om PHP og MySQL et skritt videre ved å lage en enkel blogg. Selv om det finnes utallige gode gratis bloggplattformer, er formålet med denne opplæringen ikke å lage en "bedre" blogg, men å bruke prosessen med å lage en blogg for å lære om avansert databasestrukturteknikk og hvordan man bruker data mer effektivt ved å utnytte objekter i PHP.
Enkel Blog Files.zip
benmillsdesigns.com/simpleblog/
For denne opplæringen antas det at du har noen grunnleggende forståelse av PHP, MySQL, XHTML og senere jQuery / JavaScript.
Før vi går inn i MySQL-klienten og begynner å lage våre bord, bør vi legge ut hva vi vil ha i bloggen vår. Den åpenbare tingen vi trenger å holde er blogginnlegg, og i hvert innlegg skal det inneholde en tittel, posten, en forfatter og datoen den ble lagt ut.
Nå kan vi bare lage ett bord for å holde den informasjonen, og mest sannsynlig oppnå å lage en grunnleggende blogg, men med bare ett bord vil vi ikke ha så mye kontroll over dataene våre. For eksempel kan vi bare lagre forfatterens navn i samme tabell som blogginnlegget, men hva om vi også vil lagre forfatterens e-post? Sikker! Vi legger bare til et annet felt til vårt bord ville være den åpenbare løsningen.
Problemet kommer opp når du er i veien, vil du endre e-postadressen til forfatteren. Nå må du endre det for hver enkelt bloggpost som personen har opprettet.
Så det vi skal gjøre er å lage et eget bord som heter "People", og i dette lagrer vi all informasjon vi trenger fra forfatteren, for eksempel e-postadresser, nettadresser, navn og en unik ID. Deretter i vår bloggpostbord vil vi peke på personen vi vil bruke den personens unike ID. Dette idet er referert til som en fremmednøkkel, og forholdet mellom bloggpostbordet og folketabellen kalles en til mange forhold.
En annen ting vi vil ha i bloggen vår er en tagg for hvert blogginnlegg. Igjen vil vi gjøre databasen effektiv, så vi vil lage et eget bord for våre koder. Nå hva gjør vi? Skal vi lage et felt i bloggpostbordet som er en fremmed nøkkel for vår tag? Problemet med å bruke et en-til-ett-forhold denne gangen er noen ganger blogginnleggene har mer enn ett tag; så igjen, vil vi bruke et til mange forhold. For å gjøre dette må vi opprette en annen tabell som blir kalt noe som "blog_post_tags" som vil inneholde to utenlandske nøkler, en vil være blogginnleggets ID og den andre vil være tag-IDen som blogginnlegget er knyttet til. På denne måten kan vi tildele så mange koder som vi vil ha et blogginnlegg, men kan fortsatt redigere informasjonen om den aktuelle taggen i alle innlegg med en enkel MySQL-spørring.
Nå som vi har skissert hva vi vil at vår database skal se ut, la oss lage den. Jeg bruker PhpMyAdmin siden det er den mest brukte MySQL admin klienten. Det er noen forskjellige navngivningskonvensjoner du kan bruke når du oppretter databasen, tabell og feltnavn. Jeg personlig liker å bruke alle små og understreker i stedet for mellomrom.
Merk: Hvis du ikke har PHP og MySQL på systemet eller en server som kan kjøre det, anbefaler jeg at du laster ned en frittstående installasjon av Apache, PHP og MySQL. MAMP er bra for Mac og WAMP er bra for PCer.
Først må vi lage vår database, jeg skal kalle det "nettuts_blog".
Deretter skal vi lage våre bord; den første vil være "blog_posts".
"blog_posts" vil ha fem felt: "id", "tittel", "innlegg", "author_id" og "date_posted". For "id" skal vi gjøre det til primærnøkkelen og sette den til automatisk økning. Hva dette vil gjøre er å generere vårt unike id for oss. Hver gang vi legger til et innlegg, vil det gi det et nummer som starter ved en og går opp for så mange innlegg som vi har.
Nå må vi også angi variabeltypen for hvert felt. IDet vil bli satt til å skrive int, kort for heltall, siden det bare kan være et tall og vi vil sette maksimal lengde til 11. Feltet "tittel" vil bli satt til å skrive varchar med en maksimal lengde på 255. " post "feltet vil være typen" tekst "og vi vil ikke angi en maks lengde siden innleggene kan være veldig lange. "author_id" vil være det samme som "id", men vi vil ikke sette det som vår primære nøkkel eller ha det automatisk økning, og vi vil stille "date_posted" for å skrive "Date".
Vårt neste bord blir "folk". Vi kaller det ikke "forfattere" fordi vi ikke ønsker å opprette muligheten til å registrere og legge inn kommentarer, og de ville ikke bli betraktet som forfattere.
"folk" vil inneholde fem felt også: "id", "first_name", "last_name", "url" og "email".
"id" vil bli satt som en int, primærnøkkelen, og til automatisk økning, på samme måte som vi angir id av "blog_posts". "first_name", "last_name", "url" og "email" vil alle bli satt til å skrive varchar med en maksimal lengde på 255.
Vårt neste bord vil være "tags" og vil for nå inneholde bare to felt: "id" og "navn". Nedover veien kunne vi gjøre dette mer komplekst ved å legge til en beskrivelse, men for denne opplæringen vil vi ikke. Som vi gjorde før "id" vil bli satt som int, primærnøkkelen, og til automatisk økning. "navn" vil være typen varchar og har en maksimal lengde på 255.
Og vårt siste bord, "blog_post_tags", har bare to felt: "blog_post_id" og "tag_id". De vil begge bli satt til å skrive int med en maksimal lengde på 11. Som du mest sannsynlig la merke til, satte vi ikke en primærnøkkel for dette bordet. Dette skyldes at vi aldri får data ut av denne tabellen, med mindre vi ber om et bestemt blogginnlegg eller alle innlegg i en bestemt tag-ID.
Før vi starter inn i vår egentlige PHP-kode, må vi lage våre filer og mapper. For denne opplæringen vil vi ha vår index.php i vår rotmappe, så inneholder en mappe som holder CSS-stilarket, våre JavaScript-filer, includes.php som vil holde referanser til våre objekter og MySQL-tilkobling, og blogpost.php som vil holde vår BlogPost obejct.
Nå som vi har vårt databasett, må vi lage objekter i PHP som vil håndtere dataene for oss. Objekter i programmering er en måte å trekke sammen forskjellige attributter (som variabler) og metoder som alle vedrører det samme. Objekter hjelper oss også med å organisere våre programmer mye mer. Før vi hopper inn i våre objekter for bloggen vår, la oss bare lage en enkel gjenstand slik at vi kan illustrere hva de er i et mer "virkelige liv".
Vårt objekt vil bli kalt "Bike", nå er det to typer ting som hvert objekt har, egenskaper og metoder. Egenskaper definerer objektet og metodene er hva objektet gjør. For eksempel ville vårt sykkelobjekt ha egenskaper som hjulstørrelse, antall gir, og kanskje rammestørrelsen. For metoder kan vi ha noe som "Pedal".
Nå for å gå tilbake til bloggen vår trenger vi bare ett objekt for nå kalt "BlogPost". BlogPost vil ha seks egenskaper, id, tittel, innlegg, forfatter, koder og dato lagt ut. Så la oss gjøre det i PHP.
For å definere et objekt i PHP definerer vi det som en "klasse". En klasse er strukturen til hvert objekt, eller som wikipedia beskriver det, "I objektorientert programmering er en klasse et programmeringsspråkskonstruksjon som brukes som en tegning for å lage objekter. Denne tegningen inneholder attributter og metoder som de opprettede objektene alle dele." (Http://en.wikipedia.org/wiki/Concrete_class). Vi skal åpne vår blogpost.php side og definere vårt første objekt.
Merk: I hver del av opplæringen går jeg ut av åpningen og lukking av PHP-koder; ""du må inkludere dem ved starten og slutten av dokumentet ditt.
klasse blogpost
I vår klasse trenger vi først definere våre egenskaper. For å gjøre dette må vi opprette variabler - men med "offentlig" foran dem. Bare et raskt notat, hvis du bruker PHP4, må du bruke "var" i stedet for "offentlig".
klasse blogpost offentlig $ id; offentlig $ title; offentlig $ post; offentlig $ forfatter; offentlige $ tags; offentlig $ datePosted;
Nå som vi har definert alle våre egenskaper, ønsker vi å definere vår første metode. Metoder er også beskrevet som funksjoner, men hovedforskjellen er at en metode er en funksjon inne i et objekt. Så alle metoder er også funksjoner, men ikke alle funksjoner er metoder.
Vår første metode vil bli det som kalles en konstruktør; Denne metoden kalles automatisk når vi lager en ny forekomst av BlogPost-objektet.
Den vanlige bruken av en konstruktør er slik at du kan opprette et nytt objekt og angi egenskapene til objektet raskt.
Så hva vi vil gjøre er å opprette en ny funksjon kalt __construct (), og vi skal passere i fem verdier, id, tittel, post, forfatter-ID og dato lagt ut. For hvert variabelt navn skal vi sette "inn" før ordet slik at vi kan fortelle inne i våre funksjoner hvilke variabler som blir sendt inn og hvilke variabler er allerede til stede.
klasse blogpost offentlig $ id; offentlig $ title; offentlig $ post; offentlig $ forfatter; offentlige $ tags; offentlig $ datePosted; funksjon __construct ($ inId, $ inTitle, $ inPost, $ inAuthorId, $ inDatePosted)
Problemet her er at med denne nåværende koden, hver gang vi oppretter en ny forekomst av BlogPost, må vi levere alle disse egenskapene. Men hva om vi ønsker å lage et nytt blogginnlegg og ikke har definert disse variablene ennå? For å håndtere dette, må vi overbelaste argumentene for vår funksjon, slik at hvis vi kaller funksjonen og ikke passerer i en av argumentene, vil den automatisk sette den til standardverdien.
funksjon __construct ($ inId = null, $ inTitle = null, $ inPost = null, $ inPostFull = null, $ inAuthorId = null, $ inDatePosted = null)
Som du kan se, er alt som vi gjør for å oppnå oppgaven vår, satt til hvert argument til verdien "null". Nå inne i vår konstruktør, må vi sette hver av våre variabler til våre bestått verdier. For å gjøre dette ønsker vi å sette dem til objektet vi er i akkurat nå; Vi kan gjøre dette med "dette" søkeordet. I motsetning til mange andre språk for å få tilgang til en eiendom i PHP bruker du "->" der i de fleste språk (I.E.J.W., ASP.NET) du bruker ".".
funksjon __construct ($ inId = null, $ inTitle = null, $ inPost = null, $ inPostFull = null, $ inAuthorId = null, $ inDatePosted = null) $ this-> id = $ inId; $ this-> title = $ inTitle; $ this-> post = $ inPost;
Dette fungerer for id, tittel og innlegg. Men hva med våre andre? For dato må vi reformatere dataene vi fikk fra MySQL for å være mer lesbare. Det er lett oppnådd; Vi eksploderer bare den (også kjent som splittelse i andre programmeringsspråk) og legger det sammen igjen. MySQL gir det til oss i dette formatet yyyy-mm-dd, så hvis vi eksploderer det med "-" som vår separator, får vi et array som holder tre verdier. Den første vil holde vår år, den neste vil holde vår måned, og den siste blir dagen. Nå er alt vi gjør, legg dem sammen igjen i det formatet vi ønsker. Jeg går med mm / dd / yyyy.
Accentsconagua
$ splitDate = eksplodere ("-", $ inDatePosted); $ this-> datePosted = $ splitDate [1]. "/". $ splitDate [2]. "/". $ SplitDate [0]; For forfatteren er alt vi trenger å gjøre, spør databasen til personen med ID av vår forfatter-ID. Vi kan gjøre dette med et grunnleggende MySQL-spørring.
$ query = mysql_query ("SELECT first_name, last_name FROM People WHERE id =". $ inAuthorId); $ rad = mysql_fetch_assoc ($ spørring); $ this-> author = $ row ["first_name"]. "". $ Rad [ "last_name"]; Nå vil merkene bli litt vanskeligere. Vi kommer til å trenge å snakke med databasen, så vi må opprette en MySQL-spørring. Vi vil ikke bekymre deg for databasetilkoblingen akkurat nå, som vil bli definert utenfor denne klassen. Nå er alt vi har, blogginnleggets ID. Vi kan sammenligne det med blogginnleggene i bloggen blog_post_tags, men da vil vi bare få tilbake taggens ID og må gjøre en annen spørring for å få informasjon om taggen. Det er ikke bra; Vi ønsker å være effektive, så la oss gjøre det på bare ett spørsmål!
For å gjøre dette skal vi gjøre det som kalles et left join, dette betyr at vi også skal velge data fra et annet bord, men bare når det samsvarer med dataene fra "venstre" eller våre andre valgte data. Så først, la oss bare få alle tag-IDer som er knyttet til vårt blogginnleggs ID i blog_post_tags-tabellen.
$ query = mysql_query ("SELECT * FROM blog_post_tags WHERE blog_post_tags.blog_post_id =". $ inId); La oss nå legge til venstre, og fortelle søket vårt, vi vil bare ha dataene i etikettbordet:
$ query = mysql_query ("SELECT-tagger. * FRA blog_post_tags VENSTRE JOIN (tags) ON (blog_post_tags.tag_id = tags.id) HVOR blog_post_tags.blog_post_id =". $ inId); Så nå velger spørringen alt fra tasterne og blog_posts_tags-tabellene der første blog_post_tags.blog_post_id er lik den vi oppgav, og returnerer også informasjonen om hver tag som har den taggen som er i samme rad av data som vår blog_post_id.
Nå ønsker vi å behandle dataene i PHP med en enkel stundsløyfe. Vi skal også lage to arrays som vil holde våre data: en for taggenavnet, og den andre for taggen ID. Vi vil også lage en streng for å holde alle våre koder. Vi vil først sette det til "No Tags", slik at hvis vi ikke returnerer data fra MySQL-spørringen, kommer det tilbake at vi ikke har noen koder, ellers vil verdien bli overskrevet med taggenavnene.
$ postTags = "No Tags"; $ tagArray = array (); $ tagIDArray = array (); ($ row = mysql_fetch_assoc ($ query) array_push ($ tagArray, $ row ["navn"]); array_push ($ tagIDArray, $ row ["id"]);
Nå vil vi sjekke for å sikre at arrayet har en lengde større enn null (vi vil ikke utføre all denne ekstra koden hvis vi ikke trenger). Deretter skal vi sammenkoble en streng med tagger for hver tag i vårt tagnavn-array. Vi vil bruke en enkel hvis else setning.
hvis (sizeof ($ tagArray)> 0) foreach ($ tagArray som $ tag) if ($ postTags == "No Tags") $ postTags = $ tag; ellers $ postTags = $ postTags. ",". $ Tag; $ this-> tags = $ postTags;
Du har mest sannsynlig lagt merke til at vi ikke brukte tag-ID-arrays. Vi kommer til å forlate dem alene for nå og komme tilbake til dem senere. Vi vil bare få vår blogg oppe å kjøre først.
Det siste trinnet for klassen vår er å legge til om setninger for hver egenskap slik at hvis vi ikke sender inn noe, vil det ikke forsøke å angi det nåværende objektets eiendom til ingenting (dette vil føre til en feil). Her er hele BlogPost-klassen med if-setningene lagt til:
id = $ inId; hvis (! tomt ($ inTitle)) $ this-> title = $ inTitle; hvis (! tomt ($ inPost)) $ this-> post = $ inPost; hvis (! tomt ($ inDatePosted)) $ splitDate = eksplodere ("-", $ inDatePosted); $ this-> datePosted = $ splitDate [1]. "/". $ splitDate [2]. "/". $ SplitDate [0]; hvis (! tomt ($ inAuthorId)) $ query = mysql_query ("VELG førstnavn, etternavn fra personer hvor id =". $ inAuthorId); $ rad = mysql_fetch_assoc ($ spørring); $ this-> author = $ row ["first_name"]. "". $ Rad [ "last_name"]; $ postTags = "Ingen Tags"; hvis (! tomt ($ inId)) $ query = mysql_query ("SELECT-tagger. * FRA blog_post_tags VENSTRE JOIN (tags) ON (blog_post_tags.tag_id = tags.id) WHERE blog_post_tags.blog_post_id =". $ inId); $ tagArray = array (); $ tagIDArray = array (); mens ($ row = mysql_fetch_assoc ($ query)) array_push ($ tagArray, $ row ["name"]); array_push ($ tagIDArray, $ row ["id"]); hvis (sizeof ($ tagArray)> 0) foreach ($ tagArray som $ tag) if ($ postTags == "No Tags") $ postTags = $ tag; ellers $ postTags = $ postTags. ",". $ Tag; $ this-> tags = $ postTags; ?> Nå som vår objektklasse er fullført, er de fleste av de vanskelige greiene gjort! Nå er alt vi trenger å gjøre, satt opp vår databaseforbindelse og HTML for å vise innleggene våre!
Før vi gjør noe, må vi sette opp vår include.php-fil for å holde en referanse til vårt bloggpostobjekt og koble til vår MySQL-database. Først kan vi inkludere vårt objekt med en enkel inkludere uttalelse:
inkludere 'blogpost.php';
Nå kan vi legge til vår databaseforbindelse:
$ connection = mysql_connect ("localhost", "brukernavn", "passord") eller dø ("Beklager, vi kunne ikke koble til databaseserveren.
"); $ database =" nettuts_blog "; mysql_select_db ($ database, $ connection) eller dø ("Beklager, vi kunne ikke koble til databasen.
"); Deretter må vi hente våre blogginnlegg fra databasen. For å gjøre dette skal vi lage en funksjon som kan ta opptil to argumenter. Vi vil overbelaste dem begge; slik at du kan ringe funksjonen med enten 0, 1 eller 2 argumenter.
funksjon GetBlogPosts ($ inId = null, $ inTagId = null)
Innenfor vår funksjon må vi sjekke for å se hvilke argumenter som ble sendt inn og opprette vårt MySQL-spørring tilsvarende.
funksjon GetBlogPosts ($ inId = null, $ inTagId = null) if (! tom ($ inId)) annet hvis (! tomt ($ inTagId)) annet
Så det vi gjør her, er å spørre om hvert argument ikke er tomt, er årsaken til at vi bruker den tomme funksjonen i stedet for bare å gjøre standardverdien "! = Null" sammenligning fordi tomme ikke bare kontrollerer om variabelen er null, men hvis den tom også (IE ""). Nå skal vi skrive en forespørsel avhengig av hvilke variabler vi har. Hvis vi sender inn en blogginnlegg, vil vi bare ha det enkle blogginnlegget, hvis vi gir funksjonen en inTagId, vil vi ha alle innlegg som har den taggen, og ellers vil vi bare ha alle blogginnlegg i vår database.
hvis (! tomt ($ inId)) $ query = mysql_query ("VELG * FRA blog_posts WHERE id =". $ inId. "BESTILL AV ID DESC"); ellers hvis (! tomt ($ inTagId)) $ query = mysql_query ("VELG blogg_posts. * FRA blog_post_tags VENSTRE BLINNE (blog_posts) ON (blog_post_tags.postID = blog_posts.id) HVOR blog_post_tags.tagID =". $ tagID. " BESTILL BY blog_posts.id DESC "); ellers $ query = mysql_query ("VELGE * FRA blog_posts ORDER BY ID DESC"); Det neste trinnet er å behandle dataene som returneres fra hvert spørsmål, opprette objektene, og legge dem til i en matrise for å returnere.
$ postArray = array (); ($ row = mysql_fetch_assoc ($ query)) $ myPost = ny BlogPost ($ rad ["id"], $ rad ['tittel'], $ rad ['innlegg'], $ rad ['postfull'] $ rad ['fornavn']. "". $ rad ['etternavn'], $ rad ['dateposted']); array_push ($ postArray, $ myPost); returner $ postArray;
Her er hele include.php-filens kode:
Beklager, vi kunne ikke koble til databaseserveren."); $ database =" nettuts_blog "; mysql_select_db ($ database, $ connection) eller dø ("Beklager, vi kunne ikke koble til databasen.
"), funksjon GetBlogPosts ($ inId = null, $ inTagId = null) if (! tomt ($ inId)) $ query = mysql_query (" VELG * FRA blog_posts WHERE id = ". $ inId." BESTILL AV ID DESC "); ellers hvis (! tomt ($ inTagId)) $ query = mysql_query (" VELG blogg_posts. * FRA blog_post_tags VENSTRE BLI MED (blog_posts) ON (blog_post_tags.postID = blog_posts.id) HVOR blog_post_tags.tagID = ". $ tagID. "BESTILL BY blog_posts.id DESC"); ellers $ query = mysql_query ("VELGE * FRA blog_posts ORDER BY ID DESC"); $ postArray = array (); mens ($ row = mysql_fetch_assoc ($ query) ) $ myPost = ny BlogPost ($ rad ['id'], $ rad ['tittel'], $ rad ['post'], $ rad ['postfull'], $ rad ["author_id"], $ rad ['dateposted']); array_push ($ postArray, $ myPost); returnere $ postArray;?>> Nå kan vi fortsette å vise våre data, la oss åpne vår index.php-fil og sette opp en grunnleggende HTML-side. Inne i kroppen vår vil vi opprette en divisjon med et id av "main" som vil inneholde vår blogg. Vi vil gi bloggen vår en tittel og deretter ha en andre div inne hoved som vil bli kalt "blogPosts".
Min enkle blogg
Innenfor vår bloggpost div, legger vi inn noen PHP slik at vi kan vise innleggene våre. Først skal vi inkludere vår include.php-fil og deretter ringe vår GetBlogPosts-funksjon uten argumenter for å få alle våre blogginnlegg og sett det til en gruppe som heter blogPosts.
Nå vil vi bruke en foreach loop for å vise våre blogginnlegg. Hva en foreach-sløyfe gjør for oss akkurat nå, tar en matrise og kjører koden i løkken for hvert element i arrayet, du kan også bruke en normal for sløyfe for å oppnå dette, men en foreach-sløyfe krever mindre kode.
foreach ($ blogPoser som $ post)
Innenfor sløyfen bruker vi $ post som det nåværende arrayelementet, og siden $ blogPosts er en rekke BlogPost-objekter, kan vi bare bruke "->" for å få tilgang til hver eiendom vi ønsker. La oss starte med å ekko ut tittelen på hvert blogginnlegg til vår side og bare legg til en
- som et eksempel.
foreach ($ blogPosts as $ post) echo $ post-> title. "
";
Hvis vi går til vår database og legger inn noen falske data, åpner du index.php i en nettleser, så får vi noe slikt:
La oss virkelig bygge våre innlegg i HTML. Hvert innlegg vil bli pakket inn i en div med en klasse av "innlegg". Da vil vi ha posttittelen inne i en h1-tag og selve innlegget inne i a
stikkord.
foreach ($ blogPosts as $ post) echo ""; ekko "";". $ post-> tittel."
"; ekko "". $ post-> innlegg."
"; ekko "
La oss også gi hvert innlegg en bunntekst som inkluderer postens forfatter, datooppført og postens koder. Vi legger all denne informasjonen inn i en span-kode med en klasse "footer".
foreach ($ blogPosts as $ post) echo ""; ekko "";". $ post-> tittel."
"; ekko "". $ post-> innlegg.""; ekko "Skrevet av: ". $ Post-> author." Skrevet på: ". $ Post-> datePosted." Tags: ". $ Post-> tags.""; ekko "
La oss nå se vår index.php-fil igjen i en nettleser:
Ser ut som alt fungerer! Deretter la vi legge til noen styling.
Mye bedre; Du kan se dette online her, eller klikk på de store "demo" knappene. Det er det for denne opplæringen. I en etterfølgende opplæring vil vi legge til mer funksjonalitet i bloggen vår, inkludert noen fine AJAX-funksjoner!
Jeg håper du nå har en bedre forståelse av hvordan objektorientert programmering fungerer. Selv om du ender med å gjøre flertallet av utviklingen din ved hjelp av et rammeverk, er det veldig viktig å ha en kjernekunnskap om grunnleggende. Hvis du har noen spesifikke spørsmål om denne opplæringen, ikke nøl med å tweet meg @ benemills. Jeg vil gjerne gi en spesiell takk til James Padolsey for å hjelpe meg med denne artikkelen.
Hold deg oppdatert for del 2!
