पिछले कुछ हफ्तों में NETTUTS ने shout box जैसे सरल वेब एप्लिकेशन बनाने के लिए PHP और MySQL का उपयोग शुरू करने के तरीके पर कुछ शानदार ट्यूटोरियल पोस्ट किए हैं। आज हम एक सरल ब्लॉग बनाकर एक कदम आगे PHP और MySQL के बारे में ज्ञान लेने जा रहे हैं। हालांकि अनगिनत उत्कृष्ट मुफ्त ब्लॉग प्लेटफार्म हैं, इस ट्यूटोरियल का उद्देश्य "बेहतर" ब्लॉग बनाना नहीं है बल्कि उन्नत डेटाबेस संरचना तकनीकों के बारे में जानने के लिए ब्लॉग बनाने की प्रक्रिया का उपयोग करना और PHP में ऑब्जेक्ट्स का उपयोग करके डेटा को अधिक कुशलता से उपयोग करना है।

इस ट्यूटोरियल के लिए मैं यह मानता हम कि आपके पास PHP, MySQL, XHTML, और बाद में jQuery / JavaScript पर कुछ बुनियादी समझ है।

पार्ट 1) हमारे डेटाबेस का निर्माण

हमारे MySQL क्लाइंट में जाने से पहले और हमारी टेबल बनाने शुरू करने से पहले, हमें अपने ब्लॉग में जो कुछ भी चाहिए, उसे रखना चाहिए। वह स्पष्ट चीज जो हमें रखने की ज़रूरत है वो है ब्लॉग पोस्ट, और प्रत्येक पोस्ट में इसमें एक title, post, एक author, और जिस तारीख में पोस्ट किया गया था, उसमें होना चाहिए।

अब हम केवल एक टेबल को उस जानकारी को होल्ड करने के लिए बना सकते हैं, और संभवतः एक बेसिक ब्लॉग बनाने में सक्षम हो सकते हैं, लेकिन केवल एक टेबल के साथ हमारे डेटा पर अधिक नियंत्रण नहीं होगा। उदाहरण के लिए, हम ब्लॉग पोस्ट के उसी टेबल में ऑथर का नाम स्टोर कर सकते हैं, लेकिन अगर हम ऑथर के ईमेल को भी स्टोर करना चाहते हैं तो क्या होगा? ज़रूर! हम बस अपनी टेबल में एक और फील्ड जोड़ना स्पष्ट समाधान होगा।

जब आप उस ऑथर के ईमेल एड्रेस को बदलना चाहते हैं तो नीचे समस्या आती है। अब आपको उस व्यक्ति द्वारा बनाए गए प्रत्येक ब्लॉग पोस्ट के लिए इसे बदलना होगा।

तो हम जो करने जा रहे हैं वह "People" नामक एक अलग टेबल बनाना है और इसमें हम सभी सूचनाएं जैसे कि emails, URLs, उनके नाम और एक यूनिक ID से स्टोर करेंगे। फिर हमारे ब्लॉग पोस्ट टेबल में हम उस व्यक्ति को इंगित करेंगे जिसे हम उस व्यक्ति की यूनिक ID का उपयोग करना चाहते हैं। इस ID को एक फॉरेन key के रूप में जाना जाता है और ब्लॉग पोस्ट टेबल और people टेबल के बीच रिलेशन को one-to-many रिलेशनशिप कहा जाता है।

हमारे ब्लॉग में एक और चीज जो हम चाहते हैं वह प्रत्येक ब्लॉग पोस्ट के लिए एक टैग है। फिर हम अपने डेटाबेस को कुशल बनाना चाहते हैं ताकि हम अपने टैग के लिए एक अलग टेबल तैयार कर सकें। अब हम क्या करें? क्या हमें ब्लॉग पोस्ट टेबल में एक फ़ील्ड बनाना चाहिए जो हमारे टैग के लिए एक foreign key है? इस बार one-to-one रिलेशनशिप का उपयोग करने में समस्या कभी-कभी ब्लॉग पोस्ट में एक से अधिक टैग होते हैं; तो फिर, हम one-to-many रिलेशनशिप का उपयोग करेंगे। ऐसा करने के लिए हमें एक और टेबल बनाने की आवश्यकता है जिसे "blog_post_tags" जैसे कुछ कहा जाएगा, जिसमें दो foreign key होंगी, एक ब्लॉग पोस्ट ID होगी और दूसरा टैग ID होगा जो ब्लॉग पोस्ट से जुड़ा हुआ है। इस तरह हम एक ब्लॉग पोस्ट के रूप में कई टैग असाइन कर सकते हैं लेकिन एक सरल MySQL क्वेरी के साथ सभी पोस्ट्स में उस स्पेसिफिक टैग के बारे में जानकारी अभी भी एडिट कर सकते हैं।

अब हमने बताया है कि हम अपने डेटाबेस को किस तरह दिखाना चाहते हैं, चलो इसे बनाएं। मैं PhpMyAdmin का उपयोग करूँगा क्योंकि यह सबसे व्यापक रूप से उपयोग किया जाने वाला MySQL एडमिन क्लाइंट है। आपके डेटाबेस, टेबल और फ़ील्ड नाम बनाते समय आप कुछ अलग नाम देने के कन्वेंशन का उपयोग कर सकते हैं। मैं व्यक्तिगत रूप से स्पेसेस की जगह सभी लोअरकेस और अंडरस्कोर का उपयोग करना पसंद करता हूं।

नोट: यदि आपके पास आपके सिस्टम पर PHP और MySQL नहीं है या कोई सर्वर जो इसे चला सकता है, तो मैं Apache, PHP और MySQL के स्टैंड-अलोन इंस्टॉलेशन को डाउनलोड करने की सलाह देता हूं। Macs के लिए MAMP अच्छा है और WAMP PCs के लिए अच्छा है।

सबसे पहले हमें अपना डेटाबेस बनाना होगा, मैं इसे "nettuts_blog" कहने जा रहा हूं।

इसके बाद, हम अपनी टेबल तैयार करेंगे; पहला "blog_posts" होगा।

"blog_posts" में पांच फ़ील्ड होंगे: "id", "title", "post", "author_id", और "date_posted"। "id" के लिए हम इसे primary key बनाने जा रहे हैं और इसे ऑटो-इन्क्रीमेंट के लिए सेट कर रहे हैं। यह हमारे लिए हमारी यूनिक id उत्पन्न करेगा। प्रत्येक बार जब हम एक पोस्ट जोड़ते हैं तो यह एक नंबर से शुरू होने वाला नंबर और हमारे पास जितनी अधिक पोस्ट के लिए आगे बढ़ता है।

अब हमें प्रत्येक फ़ील्ड के लिए वेरिएबल टाइप को सेट करने की भी आवश्यकता है। id को int टाइप के लिए सेट किया जाएगा, जो इन्टिजर का छोटा रूप है, क्योंकि यह केवल एक नंबर हो सकता है और हम मैक्स लेंथ 11 तक सेट करेंगे। फ़ील्ड "title" 255 की मैक्स लेंथ के साथ varchar टाइप करने के लिए सेट किया जाएगा। "post" फ़ील्ड का टाइप "text" होगा और हम मैक्स लेंथ निर्धारित नहीं करेंगे क्योंकि पोस्ट बहुत लंबी हो सकती हैं। "author_id" "id" के जैसा ही होगा लेकिन हम इसे हमारी primary key के रूप में सेट नहीं करेंगे या इसे auto increment नहीं करेंगे, और हम "date_posted" को "Date" टाइप करने के लिए सेट करेंगे।

हमारी अगली टेबल "people" होगी। हम इसे "authors" नहीं कॉल कर रहे हैं क्योंकि डाउन द रोड हम रजिस्टर करने और कमैंट्स पोस्ट करने की क्षमता बनाना चाहते हैं और उन पीपल को ऑथर्स के रूप में नहीं माना जाएगा।

"people" में पांच फ़ील्ड भी होंगे: "id", "first_name", "last_name", "url", और "email"।

"id" को int, primary key और auto increment के रूप में सेट किया जाएगा, वैसे ही हमने "blog_posts" की id सेट की है। "first_name", "last_name", "url", और "email" सभी को 255 की मैक्स लेंथ के साथ varchar टाइप के लिए सेट किया जाएगा।

हमारी अगली टेबल "tags" होगी और अब इसमें केवल दो फ़ील्ड होंगे: "id" और "name"। डाउन द रोड हम डिस्क्रिप्शन जोड़कर इसे और अधिक जटिल बना सकते हैं लेकिन इस ट्यूटोरियल के लिए, हम ऐसा नहीं करेंगे। जैसा कि हमने पहले "id" int, primary key और auto increment के रूप में सेट किया था। "name" टाइप varchar होगा और इसकी मैक्स लेंथ 255 होगी।

और हमारी आखिरी टेबल, "blog_post_tags" में केवल दो फ़ील्ड होंगे: "blog_post_id" और "tag_id"। वे दोनों 11 की मैक्स लेंथ के साथ int टाइप के लिए सेट होंगे। जैसा कि आपने अधिक संभावना है की ध्यान दिया होगा, हमने इस टेबल के लिए primary key सेट नहीं की है। ऐसा इसलिए है क्योंकि हम इस टेबल से डेटा कभी प्राप्त नहीं करेंगे ख़ास तौर पर तबतक जबतक कि हम एक स्पेसिफिक ब्लॉग पोस्ट या स्पेसिफिक टैग id की सभी पोस्ट नहीं मांग रहे हैं।

पार्ट 2) PHP में हमारे ऑब्जेक्ट्स बनाना

हमारे वास्तविक PHP कोड में शुरू करने से पहले हमें अपनी फाइलें और फ़ोल्डर्स बनाने होंगे, इस ट्यूटोरियल के लिए हमारे रूट फ़ोल्डर में index.php होगी, फिर एक फ़ोल्डर शामिल होगा जो हमारी CSS स्टाइल शीट, हमारी JavaScript फाइलों, include.php जो हमारे ऑब्जेक्ट्स और MySQL कनेक्शन को होल्ड करेगी, और blogpost.php जो हमारे BlogPost obejct को होल्ड करेगी।

अब जब हमारे पास हमारे डेटाबेस सेट हैं, तो हमें PHP में ऑब्जेक्ट्स बनाने की आवश्यकता है जो हमारे लिए डेटा को संभालेगा। प्रोग्रामिंग में ऑब्जेक्ट्स अलग-अलग ऐट्रिब्यूट्स (वेरिएबल्स के रूप में) और मेथड्स को एक साथ पुल करने का एक तरीका है जो सभी एक ही चीज़ से संबंधित हैं। ऑब्जेक्ट्स भी हमारे प्रोग्राम्स को व्यवस्थित करने में हमारी सहायता करते हैं। हमारे ब्लॉग के लिए ऑब्जेक्ट्स में कूदने से पहले, आइए एक साधारण ऑब्जेक्ट बनाएं ताकि हम यह बता सकें कि वे "रियल लाइफ" टर्म में क्या हैं।

हमारे ऑब्जेक्ट को "Bike" कहा जाएगा, अब प्रत्येक ऑब्जेक्ट में दो तरह की चीजे होती हैं, प्रॉपर्टीज और मेथड्स। प्रॉपर्टीज ऑब्जेक्ट को परिभाषित करते हैं और मेथड्स यह बताता है की ऑब्जेक्ट्स क्या करता हैं। उदाहरण के लिए हमारे Bike ऑब्जेक्ट में व्हील का आकार, गियर की संख्या, और शायद फ्रेम साइज जैसे प्रॉपर्टीज होंगे। मेथड्स के लिए हमारे पास "Pedal" जैसा कुछ हो सकता है।

अब हमारे ब्लॉग पर वापस जाने के लिए, हमें केवल "BlogPost" नामक एक ऑब्जेक्ट की आवश्यकता है। BlogPost में छह प्रॉपर्टीज, id, title, post, author, tags, और पोस्ट की तारीख होगी। तो इसे PHP में बनाते हैं।

PHP में किसी ऑब्जेक्ट को परिभाषित करने के लिए हम इसे "class" के रूप में परिभाषित करते हैं। एक class प्रत्येक ऑब्जेक्ट की संरचना है, या wikipedia इसका वर्णन करता है, "ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग में, एक क्लास एक प्रोग्रामिंग लैंग्वेज कंस्ट्रक्ट है जिसे ऑब्जेक्ट्स को बनाने के लिए ब्लूप्रिंट के रूप में उपयोग किया जाता है। इस ब्लूप्रिंट में ऐट्रिब्यूट्स और मेथड्स को शामिल किया गया है जो सभी ऑब्जेक्ट्स शेयर करें।" (http://en.wikipedia.org/wiki/Concrete_class)। हम अपने blogpost.php पेज को खोलने जा रहे हैं और हमारा पहला ऑब्जेक्ट परिभाषित कर रहे हैं।

नोट: ट्यूटोरियल के प्रत्येक सेक्शन में, मैं ओपनिंग और क्लोजिंग PHP टैग छोड़ने जा रहा हूं; "<?php" और "?>" आपको उन्हें अपने डॉक्यूमेंट की शुरुआत और अंत में शामिल करने की आवश्यकता होगी।

class BlogPost
{
}

हमारी क्लास में हमें पहले अपनी प्रॉपर्टीज को परिभाषित करने की आवश्यकता है। ऐसा करने के लिए, हमें वेरिएबल्स बनाने है - लेकिन उनके सामने "public" के साथ। बस एक त्वरित नोट, यदि आप PHP4 का उपयोग कर रहे हैं तो आपको "public" के बजाय "var" का उपयोग करना होगा।

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

अब जब हमारे पास हमारे सभी प्रॉपर्टीज परिभाषित हैं, तो हम अपने पहले मेथड को परिभाषित करना चाहते हैं। मेथड्स को फंक्शन्स के रूप में भी वर्णित किया गया है, लेकिन मुख्य अंतर यह है कि एक मेथड किसी ऑब्जेक्ट के अंदर एक फ़ंक्शन है। तो सभी मेथड्स फंक्शन्स भी हैं लेकिन सभी फंक्शन्स मेथड्स नहीं हैं।

हमारा पहला मेथड कन्स्ट्रक्टर कहलाएगा; जब भी हम BlogPost ऑब्जेक्ट का नया इंस्टैंस बनाते हैं तो यह मेथड स्वचालित रूप से कॉल किया जाता है।

एक कन्स्ट्रक्टर का सामान्य उपयोग इतना है कि आप एक नया ऑब्जेक्ट बना सकते हैं और उस ऑब्जेक्ट की प्रॉपर्टीज को जल्दी से सेट कर सकते हैं।

तो हम यह करना चाहते हैं कि __construct() नामक एक नया फ़ंक्शन बनाते हैं और हम पांच वैल्यूज, id, title, post, author id और पोस्ट की तारीख को पास करने जा रहे हैं। प्रत्येक वेरिएबल नाम के लिए हम शब्द से पहले "in" डालने जा रहे हैं ताकि हम अपने फंक्शन्स के अंदर बता सकें कि कौन से वेरिएबल पारित किए जा रहे हैं और कौन से वेरिएबल पहले से मौजूद हैं।

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

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

	}
 }

यहां समस्या यह है कि, इस वर्तमान कोड के साथ, हर बार जब हम BlogPost का एक नया इंस्टैंस बनाते हैं तो हमें उन सभी प्रॉपर्टीज को सप्लाई करने की आवश्यकता होती है। लेकिन क्या होगा यदि हम एक नया ब्लॉग पोस्ट बनाना चाहते हैं और अभी तक उन वेरिएबल्स को डिफाइन नहीं किया है? इसे संभालने के लिए, हमें अपने फ़ंक्शन के लिए आर्ग्यूमेंट्स को "overload" करने की आवश्यकता है ताकि यदि हम फ़ंक्शन को कॉल करते हैं और आर्ग्यूमेंट्स में से किसी एक में पास नहीं करते हैं, तो यह स्वचालित रूप से इसे डिफ़ॉल्ट वैल्यू पर सेट कर देगा।

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

जैसा कि आप देख सकते हैं, हम अपने कार्य को पूरा करने के लिए जो करते हैं, वह प्रत्येक आर्गुमेंट को "null" वैल्यू पर सेट करता है। अब हमारे कन्स्ट्रक्टर के अंदर, हमें अपने प्रत्येक वेरिएबल को हमारे पास की गयी वैल्यूज में सेट करने की आवश्यकता है। ऐसा करने के लिए हम उन्हें उस ऑब्जेक्ट पर सेट करना चाहेंगे जिसमे हम अभी हैं; हम इसे "this" कीवर्ड से कर सकते हैं। PHP में किसी प्रॉपर्टी तक पहुंचने के लिए कई अन्य लैंग्वेजेज के विपरीत आप "->" का उपयोग करते हैं, जहां अधिकांश लैंग्वेजेज (I.E. JavaScript, ASP.NET) में आप "." का उपयोग करते हैं।

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

यह id, title और post के लिए काम करता है। लेकिन हमारे अन्य के बारे में क्या? date के लिए हमें MySQL से प्राप्त डेटा को और अधिक readable करने के लिए हमें सुधारने की आवश्यकता होगी। यह आसानी से पूरा कर लिया जाएगा; हम बस इसे एक्सप्लोड करते हैं (जिसे अन्य प्रोग्रामिंग लैंग्वेजेज में स्प्लिटिंग भी कहा जाता है) और फिर इसे एक साथ वापस रख दें। MySQL हमें इस फॉर्मेट yyyy-mm-dd में देता है, इसलिए अगर हम इसे "-" का प्रयोग करके एक्सप्लोड करते हैं तो हमारे सेपरेटर के साथ हमे एक array प्राप्त होता है तीन वैल्यूज के साथ। पहला हमारे साल को होल्ड करेगा, अगला महीने को होल्ड करेगा, और आखिरी दिन होगा। अब हम जो करेंगे वो होगा उन्हें जिस किसी भी फॉर्मेट में हम चाहते हैं वापस रख देना। मैं mm/dd/yyyy का प्रयोग कर रहा हूँ।

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

ऑथर के लिए, हमें बस इतना करना है कि हमारे ऑथर ID की id वाले व्यक्ति के लिए डेटाबेस से पूछें। हम इसे बेसिक MySQL क्वेरी के साथ कर सकते हैं।

$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"];

Left Join

अब टैग थोड़ा और मुश्किल हो जाएगा। हमें डेटाबेस से बात करने की आवश्यकता होगी, इसलिए हमें एक MySQL क्वेरी बनाने की आवश्यकता है। हम अभी डेटाबेस कनेक्शन के बारे में चिंता नहीं करेंगे, जिसे इस क्लास के बाहर परिभाषित किया जाएगा। अब हमारे पास ब्लॉग पोस्ट ID है। हम इसकी तुलना हमारे blog_post_tags टेबल में ब्लॉग पोस्ट टैग से कर सकते हैं लेकिन फिर हम केवल टैग की id वापस ले लेंगे और टैग के बारे में जानकारी प्राप्त करने के लिए एक और क्वेरी करने की आवश्यकता होगी। यह अच्छा नहीं है; हम एफिसिएंट बनना चाहते हैं तो चलिए इसे सिर्फ एक क्वेरी में करते हैं!

ऐसा करने के लिए हम left join करने के लिए जा रहे हैं, इसका मतलब है कि हम किसी अन्य टेबल से डेटा भी चुनने जा रहे हैं, लेकिन केवल तभी जब यह "left" या हमारे अन्य चुने गए डेटा से मेल खाता है। तो सबसे पहले blog_post_tags टेबल में हमारे ब्लॉग पोस्ट ID से जुड़े सभी टैग IDs प्राप्त करें।

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

आइए अब हमारे left join को जोड़े और हमारी क्वेरी को बताएं की हम केवल tags टेबल के डेटा को चाहते हैं:

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

तो अब क्वेरी टैग और blog_posts_tags टेबल से सभी को सेलेक्ट कर रही है, जहां पहले blog_post_tags.blog_post_id हमारे द्वारा प्रदान किए गए के बराबर है और फिर प्रत्येक टैग के बारे में जानकारी भी देता है जिसमें tag_id है जो हमारे blog_post_id के समान डेटा में है।

अब हम उस डेटा को PHP में सरल while लूप के साथ प्रोसेस करना चाहते हैं। हम दो array भी बनाने जा रहे हैं जो हमारे डेटा को पकड़ेंगे: एक टैग के नाम के लिए, और दूसरा टैग की id के लिए। हम अपने सभी टैग को होल्ड करने के लिए एक स्ट्रिंग भी बनाएंगे। हम पहले इसे "No Tags" पर सेट करेंगे ताकि अगर हम अपने MySQL क्वेरी से कोई डेटा नहीं पाएंगे, तो यह रीटर्न करेगा कि हमारे पास कोई टैग नहीं है, अन्यथा यह वैल्यू टैग के नामों के साथ ओवरराइट हो जाएगी।

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

अब हम यह सुनिश्चित करने के लिए जांच करेंगे कि array की लंबाई शून्य से अधिक है (यदि हम नहीं चाहते हैं तो हम इस अतिरिक्त कोड को नहीं करेंगे)। इसके बाद, हमारे टैग नाम वाले array में प्रत्येक टैग के लिए, हम टैग की एक स्ट्रिंग को जोड़ना चाहते हैं। हम एक सिंपल सी if else स्टेटमेंट का प्रयोग करेंगे।

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

काफी अधिक संभावना है कि आपने नोटिस किया होगा कि हमने टैग id array का उपयोग नहीं किया है। हम अभी उनको अकेले छोड़ने जा रहे हैं और बाद में उनके पास वापस आ जाएंगे। हम सिर्फ हमारे ब्लॉग को प्राप्त करना और पहले चलाना चाहते हैं।

हमारी क्लास के लिए आखिरी कदम यह है कि प्रत्येक प्रॉपर्टी के लिए स्टेटमेंट्स को जोड़ना है ताकि यदि हम कुछ भी नहीं पास करते हैं, तो यह करंट ऑब्जेक्ट की प्रॉपर्टी को कुछ भी सेट करने की कोशिश नहीं करेगा (इससे कोई error आएगा)। if स्टेटमेंट को जोड़कर संपूर्ण BlogPost क्लास यहां दी गई है:

<?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;
}

}

?>

अब जब हमारी ऑब्जेक्ट क्लास पूरी हो गई है, तो अधिकांश कड़ी मेहनत ख़त्म हो गयी! अब हमें बस हमारे डेटाबेस कनेक्शन और HTML को हमारी पोस्ट प्रदर्शित करने के लिए सेट करना है!

पार्ट 3) MySQL से डेटा प्राप्त करना और इसे PHP के साथ प्रदर्शित करना

कुछ भी करने से पहले हमें हमारी BlogPost ऑब्जेक्ट का रिफरेन्स रखने और हमारे MySQL डेटाबेस से कनेक्ट करने के लिए हमारी include.php फ़ाइल सेट अप करने की आवश्यकता है। सबसे पहले हमारे ऑब्जेक्ट को सिंपल include स्टेटमेंट के साथ शामिल करने दें:

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>");

इसके बाद, हमें डेटाबेस से हमारे ब्लॉग पोस्ट रेट्रीवे करने की आवश्यकता है। ऐसा करने के लिए, हम एक ऐसा फंक्शन बनाने जा रहे हैं जिसमें दो आर्गुमेंट हो सकते हैं। हम दोनों को overload करेंगे; इसलिए आप फ़ंक्शन को 0, 1, या 2 आर्ग्यूमेंट्स के साथ कॉल कर सकते हैं।

function GetBlogPosts($inId=null, $inTagId=null)
{

}

हमारे फंक्शन के अंदर हमें यह देखने के लिए जांच करनी है कि कौन से आर्गुमेंट पारित किए गए थे और तदनुसार हमारी MySQL क्वेरी बनाएं।

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

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

	}
	else
	{

	}
}

तो हम यहां जो कर रहे हैं वह है कि यह पूछ रहा है कि क्या प्रत्येक आर्गुमेंट खाली नहीं है, कारण है कि हम स्टैण्डर्ड "!= null" तुलना करने के बजाए empty फ़ंक्शन का उपयोग कर रहे हैं क्योंकि empty न केवल वेरिएबल को चेक करता है कि यह null है की नहीं, बल्कि साथ ही यह empty को भी चेक करता है (I.E. "")। अब हम जो वेरिएबल हमारे पास है उसके आधार पर एक क्वेरी लिखेंगे। अगर हम एक ब्लॉग पोस्ट ID पास करते हैं तो हम केवल उस ब्लॉग पोस्ट को चाहते हैं, अगर हम फ़ंक्शन को एक TagId देते हैं तो हम उस टैग के सभी पोस्ट चाहते हैं, और अन्यथा हम अपने डेटाबेस में सभी ब्लॉग पोस्ट चाहते हैं।

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");
}

अगला स्टेप प्रत्येक क्वेरी से लौटाए गए डेटा को प्रोसेस करना है, ऑब्जेक्ट्स बनाना है, और फिर उन्हें रीटर्न करने के लिए array में जोड़ना है।

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

यहां संपूर्ण includes.php फाइल के कोड्स शामिल है:

<?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;
}
?>

अब हम अपने डेटा को प्रदर्शित करने के लिए आगे बढ़ सकते हैं, हमारी index.php फ़ाइल खोलने और बेसिक HTML पेज सेट अप करने दें। हमारे बॉडी के अंदर हम "main" की एक id के साथ एक डिवीज़न तैयार करेंगे जिसमें हमारे ब्लॉग होंगे। हम अपने ब्लॉग को एक टाइटल देंगे और उसके बाद मुख्य रूप से दूसरा div होगा जिसे "blogPosts" कहा जाएगा।

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

	</div>
</div>

हमारे blogPosts div के अंदर, हम कुछ PHP डाल देंगे ताकि हम अपनी पोस्ट प्रदर्शित कर सकें। सबसे पहले हम अपनी include.php फ़ाइल को शामिल करने जा रहे हैं और फिर हमारे GetBlogPosts फ़ंक्शन को हमारे सभी ब्लॉग पोस्ट प्राप्त करने के लिए कोई आर्गुमेंट नहीं देते हैं और इसे blogPosts नामक array में सेट करते हैं।

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

$blogPosts = GetBlogPosts();
?>

अब, हम अपने ब्लॉग पोस्ट प्रदर्शित करने के लिए एक foreach लूप का उपयोग करेंगे। हमारे लिए एक foreach लूप अभी क्या करता है एक array लेता है और array में प्रत्येक आइटम के लिए लूप में कोड एक्सेक्यूट करता है, आप इसे प्राप्त करने के लिए नार्मल for लूप का उपयोग भी कर सकते हैं लेकिन foreach लूप को कम कोड की आवश्यकता होती है।

foreach ($blogPosts as $post)
{

}

लूप के अंदर, हम वर्तमान पोस्ट आइटम के रूप में $post का उपयोग करते हैं, और चूंकि $blogPosts BlogPost ऑब्जेक्ट्स का एक array है, हम केवल प्रत्येक प्रॉपर्टी को एक्सेस करने के लिए "->" का उपयोग कर सकते हैं। आइए बस हमारे ब्लॉग पर प्रत्येक ब्लॉग पोस्ट के टाइटल को echo करके शुरू करें और एक उदाहरण के रूप में एक <br/> जोड़ें।

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

अगर हम अपने डेटाबेस में जाते हैं और कुछ नकली डेटा डालते हैं, तो ब्राउज़र में index.php खोलें, हमें ऐसा कुछ मिल जाएगा:

आइए वास्तव में HTML में हमारी पोस्ट बनाएं। प्रत्येक पोस्ट को "post" की क्लास के साथ एक div में लपेटा जाएगा। फिर हमारे पास एक h1 टैग के अंदर पोस्ट टाइटल और <p> टैग के अंदर वास्तविक पोस्ट होगा। </p>

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

आइए प्रत्येक पोस्ट को एक फुटर भी दें जिसमें पोस्ट के ऑथर, पोस्ट की गई तारीख और पोस्ट के टैग शामिल होंगे। हम इस जानकारी को एक क्लास "footer" के साथ एक span टैग के भीतर रखेंगे।

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>";
}

आइए अब एक ब्राउज़र में हमारी index.php फ़ाइल को देखें:

ऐसा लगता है कि यह सब काम कर रहा है! इसके बाद, चलो कुछ स्टाइल जोड़ें।

काफी बेहतर; आप इसे यहां ऑनलाइन देख सकते हैं या बड़े "demo" बटन पर क्लिक कर सकते हैं। इस ट्यूटोरियल के लिए इतना ही है। बाद के ट्यूटोरियल में, हम कुछ अच्छे AJAX कार्यक्षमता सहित हमारे ब्लॉग में और अधिक फंक्शनलिटी जोड़ देंगे!

मुझे उम्मीद है कि अब ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग कैसे काम करता है आपको इसकी बेहतर समझ है। यहां तक कि यदि आप फ्रेमवर्क का उपयोग करके अपने अधिकांश डेवलपमेंट को समाप्त करते हैं, तो फंडामेंटल की कोर समझ रखने के लिए यह बहुत महत्वपूर्ण है। यदि आपके पास इस ट्यूटोरियल के बारे में कोई विशिष्ट प्रश्न है, तो मुझे @benemills में ट्वीट करने में संकोच न करें। मैं इस लेख के साथ मेरी मदद करने के लिए James Padolsey को विशेष धन्यवाद देना चाहता हूं।

Part 2 के लिए बने रहें!

• अधिक डेली वेब डेवलपमेंट tuts और आर्टिकल्स के लिए NETTUTS RSS Feed की सदस्यता लें।