वेब विकास जाओ

लेख गो से कोडलैब पर आधारित है, लेकिन यह इसके लिए सीमित नहीं है। जैसा कि आप इस लेख के माध्यम से पढ़ते हैं, आप क्रमशः वेब एप्लिकेशन, टेम्प्लेट और फ़िल्टर इनपुट बनाने के लिए http, टेम्पलेट, regexp लाइब्रेरी का उपयोग करके गो डेटा संरचनाओं, डायनेमिक सरणियों के बारे में जान सकते हैं।

लेख को समझने के लिए, आपको प्रोग्राम करने में थोड़ा सक्षम होना चाहिए, न कि यूनिक्स और वेब के शब्दों से डरना चाहिए। भाषा की मूल बातें लेख में बताई जाएंगी।

स्थापना जाओ

इसलिए, गो के साथ काम करने के लिए आपको सबसे पहले लिनक्स, फ्रीबीएसडी (ओएस एक्स) की जरूरत है, हालांकि मिनगीडब्लू विंडोज पर भी काम करेगा ।
गो को स्थापित करने की आवश्यकता है, इसके लिए आपको कुछ ऐसा करने की आवश्यकता है जैसे कि (dpkg वाले सिस्टम के लिए निर्देश दिए गए हैं):

 $ sudo apt-get install bison ed gawk gcc libc6-dev make # build tools
 $ sudo apt-get install अजगर-सेटप्टूलस अजगर-देव बिल्ड-एसेंशियल # बिल्ड और इंस्टॉल टूल्स
 $ sudo easy_install mercurial # यदि आपके पास अभी तक एक नहीं है, तो इसे रिपॉजिटरी (apt के माध्यम से) से इंस्टॉल नहीं करना बेहतर है
 $ hg क्लोन -r रिलीज़ https://go.googlecode.com/hg/ जाना
 $ cd go / src
 $ ./all.bash

यदि सब ठीक है, तो आप निम्नलिखित को जोड़ सकते हैं ~ / .bashrc या ~ / .profile :

 GOROOT = $ HOME / go निर्यात करें
 OS आर्किटेक्चर के आधार पर GOARCH = 386 # या amd64 निर्यात करें
 GOOS = linux निर्यात करें
 निर्यात GOBIN = $ GOROOT / बिन
 पथ = $ पाथ: $ गोबिन

जब आप शेल को फिर से दर्ज करते हैं और कंपाइलर (i386 के लिए 8g या amd64 के लिए 6g पर कॉल करते हैं, तो 8g होगा) हमें एक मदद संदेश मिलता है:

 gc: उपयोग 8g [झंडे] file.go ...

इसका मतलब है कि गो स्थापित है और काम कर रहा है, आप सीधे आवेदन पर जा सकते हैं।

प्रारंभ। डेटा संरचनाएं

आवेदन के लिए एक निर्देशिका बनाएँ:

  $ mkdir ~ / गौकी
 $ cd ~ / गौिकी

चलो एक पाठ संपादक ( विम और emacs के लिए बाँधने ) का उपयोग करके निम्नलिखित सामग्रियों के साथ एक wiki.go फ़ाइल बनाते हैं:

  पैकेज मुख्य
 आयात (
	 "FMT"
	 "आईओ / आईयूटिल"
	 "ओएस"
 )

नाम से यह स्पष्ट है कि हमारा आवेदन हमें पृष्ठों को संपादित करने और सहेजने की अनुमति देगा।
यह कोड गो मानक पुस्तकालय से fmt, ioutil और os पुस्तकालयों का आयात करता है। बाद में हम कुछ अन्य पुस्तकालय जोड़ेंगे।

कई डेटा संरचनाओं को परिभाषित करें। एक विकी एक शरीर और एक शीर्षक के साथ जुड़े पृष्ठों का एक संग्रह है। संबंधित डेटा संरचना में दो फ़ील्ड होंगे:

  पृष्ठ संरचना टाइप करें {
	 शीर्षक स्ट्रिंग
	 शरीर [] बाइट
 } 

[] बाइट डेटा प्रकार बाइट प्रकार का एक टुकड़ा है, एक गतिशील सरणी का एक एनालॉग (अधिक: प्रभावी गो )। लेख का मुख्य भाग [] बाइट में संग्रहीत किया जाता है , और मानक पुस्तकालयों के साथ काम करने की सुविधा के लिए स्ट्रिंग में नहीं।

डेटा संरचना का वर्णन है कि डेटा को मेमोरी में कैसे संग्रहीत किया जाता है। लेकिन क्या होगा अगर आपको लंबे समय तक डेटा बचाने की आवश्यकता है? डिस्क को सहेजने के लिए हम सहेजने की विधि लागू करते हैं:

  func (p * पेज) सेव () os.Error {
	 फ़ाइल नाम: = p.title + ".txt"
	 वापसी ioutil.WriteFile (फ़ाइल नाम, पी। लो, 0600)
 } 

इस फ़ंक्शन के हस्ताक्षर में लिखा है: "यह बचत विधि है, जो पेज पॉइंटर पर लागू होती है, मापदंडों के बिना, प्रकार का मान लौटाती है । Error ।"

यह विधि पाठ को फ़ाइल में सहेजेगी। सरलता के लिए, हम मानते हैं कि हेडर फ़ाइल नाम है। यदि यह पर्याप्त सुरक्षित नहीं लगता है, तो आप क्रिप्टो / md5 आयात कर सकते हैं और md5.New (फ़ाइल नाम) कॉल का उपयोग कर सकते हैं।

वापसी का मान प्रकार os.Error का होगा , जो WriteFile कॉल के रिटर्न मान के बराबर है (किसी फ़ाइल में स्लाइस लिखने के लिए मानक लाइब्रेरी फ़ंक्शन)। ऐसा इसलिए किया जाता है ताकि भविष्य में किसी फ़ाइल को सहेजने की त्रुटि को संभालना संभव हो सके। यदि कोई समस्या नहीं है, तो page.save () शून्य वापस आ जाएगी (संकेत, इंटरफेस और कुछ अन्य प्रकारों के लिए एक शून्य मान)।

ऑक्टेल निरंतर 0600, WriteFile कॉल के लिए तीसरा पैरामीटर, इंगित करता है कि फ़ाइल केवल वर्तमान उपयोगकर्ता के लिए पढ़ने और लिखने की अनुमतियों के साथ सहेजी गई है।

पेज लोड करना भी दिलचस्प होगा:

  func loadPage (शीर्षक स्ट्रिंग) * पृष्ठ {
	 फ़ाइल नाम: = शीर्षक + ".txt"
	 शरीर, _: = ioutil.ReadFile (फ़ाइल नाम)
	 वापसी और पृष्ठ {शीर्षक: शीर्षक, शरीर: शरीर}
 } 

इस फ़ंक्शन को हेडर से फ़ाइल का नाम मिलता है, सामग्री को प्रकार पृष्ठ के एक चर में पढ़ता है, और इसे एक संकेतक लौटाता है।

गो में फ़ंक्शंस कई मान वापस कर सकते हैं। Io.ReadFile मानक लाइब्रेरी फ़ंक्शन रिटर्न [] बाइट और os.Error । लोडपेज फ़ंक्शन में त्रुटियां अभी तक संसाधित नहीं हुई हैं: अंडरस्कोर का अर्थ है "इस मूल्य को न बचाएं"।

यदि ReadFile में कोई त्रुटि होती है तो क्या होगा? उदाहरण के लिए, उस शीर्षक के साथ कोई पृष्ठ नहीं है। यह एक महत्वपूर्ण गलती है; इसे नजरअंदाज नहीं किया जा सकता है। हमारे फ़ंक्शन को दो मान भी लौटाएँ : * पृष्ठ और os.Error ।

  func loadPage (शीर्षक स्ट्रिंग) (* पृष्ठ, os.Error) {
	 फ़ाइल नाम: = शीर्षक + ".txt"
	 बॉडी, इरेट: = ioutil.ReadFile (फ़ाइल नाम)
	 अगर गलत है! = nil {
		 एनआईएल, एर
	 }
	 वापसी और पृष्ठ {शीर्षक: शीर्षक, शरीर: शरीर}, नील
 } 

अब आप दूसरे पैरामीटर के मूल्य की जांच कर सकते हैं: यदि यह शून्य है , तो पृष्ठ सफलतापूर्वक लोड किया गया है। अन्यथा, यह os.Error प्रकार का मान होगा।

इसलिए, हमारे पास लोडिंग और अनलोडिंग की एक डेटा संरचना और तरीके हैं। यह जांचने का समय है कि यह कैसे काम करता है:

  दुर्गंध मुख्य () {
	 p1: = & पेज {शीर्षक: "टेस्टपेज", बॉडी: [] बाइट ("टेस्ट पेज।")}
	 p1.save ()
	 P2, _: = loadPage ("टेस्टपेज")
	 fmt.Println (स्ट्रिंग (P2.body))
 } 

इस कोड को संकलित और निष्पादित करने के बाद, TestPage.txt फ़ाइल में मान p1-> बॉडी होगी । उसके बाद, यह मान P2 चर में लोड किया जाता है और प्रदर्शित किया जाता है।

प्रोग्राम बनाने और चलाने के लिए, आपको निम्नलिखित कार्य करने होंगे:

  $ 8g wiki.go
 $ 8 एल विकी ।8
 $ ./8.out
 यह एक नमूना पृष्ठ है।

Http लाइब्रेरी

गो का सबसे सरल वेब सर्वर इस तरह दिखता है:

  पैकेज मुख्य
 आयात (
	 "FMT"
	 "Http"
 )
 func handler (w http.ResponseWriter, r * http.Request) {
	 fmt.Fprintf (w, "हैलो% s!", r.URL.Path [1:])
 }
 दुर्गंध मुख्य () {
	 http.andleFunc ("/", हैंडलर)
	 http.ListenAndServe (": 8080", नील)
 } 

मुख्य फ़ंक्शन http.HandleFunc को कॉल करता है , जो http लाइब्रेरी को बताता है कि सभी प्रकार के अनुरोध ( "/" ) हैंडलर फ़ंक्शन द्वारा नियंत्रित किए जाते हैं।

Http.ListenAndServe की अगली कॉल के द्वारा , हम निर्धारित करते हैं कि हम पोर्ट 8080 ( ": 8080" ) पर सभी इंटरफेस पर अनुरोधों को संसाधित करना चाहते हैं। दूसरा पैरामीटर अभी तक आवश्यक नहीं है। कार्यक्रम जबरन समाप्ति तक इस मोड में काम करेगा।

हैंडलर फ़ंक्शन http.andlerFunc प्रकार का है। यह http.esponseWriter और एक सूचक को http.equest पैरामीटर के रूप में लेता है।

Http.ResponseWriter प्रकार का मान http प्रतिक्रिया उत्पन्न करता है; वहां डेटा लिखना ( Fprintf को कॉल करके ) हम उपयोगकर्ता को पृष्ठ की सामग्री लौटाते हैं।

Http.Request डेटा संरचना एक उपयोगकर्ता अनुरोध है। स्ट्रिंग r.URL.Path पथ है। प्रत्यय [1:] का अर्थ है "पहले चरित्र से अंत तक पथ स्लाइस (विकल्प) प्राप्त करें", अर्थात अग्रणी स्लैश को हटा दें।

ब्राउज़र लॉन्च करके और URL http: // localhost: 8080 / habrahabr खोलकर, हम वांछित पृष्ठ देखेंगे:

  हाय हब्बर! 

पृष्ठ वापस करने के लिए http का उपयोग करना

Http लाइब्रेरी आयात करें:

  आयात (
	 "FMT"
	 "Http"
	 "आईओ / आईयूटिल"
	 "ओएस"
 )

लेख प्रदर्शित करने के लिए एक हैंडलर बनाएं:

 const lenPath = len ("/ view /")

 func viewHandler (डब्ल्यू http.esponseWriter, आर * http.Request) {
	 शीर्षक: = r.URL.Path [lenPath:]
	 पी, _: = लोडपेज (शीर्षक)
	 fmt.Fprintf (w, "<h1>% s </ h1> <div>% s </ div>", p.title, p.body)
 } 

सबसे पहले, यह फ़ंक्शन r.URL.Path से शीर्ष लेख को दिए गए URL के पथ घटकों को पुनः प्राप्त करता है। वैश्विक निरंतर लेनपाठ पथ की लंबाई "/ दृश्य /" है जो हमारे सिस्टम में लेख के पाठ को देखने का संकेत देता है। प्रतिस्थापन [lenPath:] पर प्रकाश डाला गया है , अर्थात् , लेख का शीर्षक, उपसर्ग को बाहर रखा गया है।

फ़ंक्शन डेटा को लोड करता है, इसे सरल एचटीएमएल टैग के साथ पूरक करता है और डब्ल्यू , टाइप http.esponseWriter के एक पैरामीटर को लिखता है ।

पुन: उपयोग किए गए _ प्रकार के रिटर्न मान को अनदेखा करने के लिए os.Error। यह सरलता के लिए किया जाता है और आम तौर पर ऐसा नहीं किया जाता है। नीचे आप पाएंगे कि इस तरह की त्रुटियों को सही तरीके से कैसे संभालना है।

इस हैंडलर को कॉल करने के लिए, हम मुख्य फ़ंक्शन को लिखते हैं जो http को पथ / दृश्य के साथ अनुरोधों को संसाधित करने के लिए उपयुक्त व्यूहैंडलर के साथ आरंभ करता है।

  दुर्गंध मुख्य () {
	 http.andleFunc ("/ view /", viewHandler)
	 http.ListenAndServe (": 8080", नील)
 } 

एक परीक्षण पृष्ठ बनाएँ (फ़ाइल test.txt में ), कोड संकलित करें और पृष्ठ प्रदर्शित करने का प्रयास करें:

  $ गूंज "नमस्ते दुनिया"> test.txt
 $ 8g wiki.go
 $ 8 एल विकी ।8
 $ ./8.out 

जबकि हमारा सर्वर चल रहा है, शीर्षक "परीक्षण" वाला एक पृष्ठ जिसमें "हैलो वर्ल्ड" शब्द http: // localhost: 8080 / view / test पर उपलब्ध होगा ।

पेज बदलें

पृष्ठों को संपादित करने की क्षमता के बिना यह किस तरह का विकी है? आइए दो नए हैंडलर बनाएं: एडहैंडलर को एडिट फॉर्म और सेवहैंडलर प्रदर्शित करने के लिए प्राप्त डेटा को सेव करने के लिए।

सबसे पहले, उन्हें मुख्य () में जोड़ें:

  दुर्गंध मुख्य () {
	 http.andleFunc ("/ view /", viewHandler)
	 http.HandleFunc ("/ edit /", editHandler)
	 http.andleFunc ("/ save /", saveHandler)
	 http.ListenAndServe (": 8080", नील)
 } 

EditHandler फ़ंक्शन पृष्ठ को लोड करता है (या ऐसा कोई पृष्ठ नहीं होने पर एक खाली संरचना बनाता है), और फ़ॉर्म प्रदर्शित करता है:

  func editHandler (w http.ResponseWriter, r * http.Request) {
	 शीर्षक: = r.URL.Path [lenPath:]
	 पी, इरेट: = लोडपेज (शीर्षक)
	 अगर गलत है! = nil {
		 p = & पृष्ठ {शीर्षक: शीर्षक}
	 }
	 fmt.Fprintf (w, "<h1> संपादन% s </ h1>" +
		 "<फ़ॉर्म कार्रवाई = \" / सहेजें /% s \ "विधि = \" POST \ ">" +
		 "<पाठ क्षेत्र का नाम = \" शरीर \ ">% s </ पाठ क्षेत्र>" +
		 "<इनपुट प्रकार = \" सबमिट करें \ "मूल्य = \" सहेजें \ ">" +
		 "</ फार्म>",
		 p.title, p.title, p.body)
 } 

फ़ंक्शन अच्छी तरह से और सही ढंग से काम करता है, लेकिन यह बदसूरत दिखता है। इसका कारण html हार्डकोड है, लेकिन यह ठीक करने योग्य है।

पुस्तकालय का खाका

टेम्पलेट लाइब्रेरी मानक गो लाइब्रेरी का हिस्सा है। हम कोड के बाहर html मार्कअप को स्टोर करने के लिए टेम्प्लेट का उपयोग कर सकते हैं ताकि मार्कअप को पुन: उपयोग के बिना बदला जा सके।

सबसे पहले, टेम्पलेट आयात करें:

  आयात (
	 "Http"
	 "आईओ / आईयूटिल"
	 "ओएस"
	 "खाका"
 ) 

निम्नलिखित सामग्री के साथ edit.html फ़ाइल में एक प्रपत्र टेम्पलेट बनाएँ:

  <h1> संपादन {शीर्षक} </ h1>

 <फ़ॉर्म कार्रवाई = "/ सहेजें / {शीर्षक}" विधि = "POST">
 <div> <text क्षेत्र का नाम = "शरीर" पंक्तियाँ = "20" बछड़े = "80"> {शरीर | html} </ पाठ क्षेत्र> </ div>
 <div> <इनपुट प्रकार = "सबमिट" मूल्य = "सहेजें"> </ div>
 </ फार्म> 

टेम्पलेट का उपयोग करने के लिए editHandler बदलें:

  func editHandler (w http.ResponseWriter, r * http.Request) {
	 शीर्षक: = r.URL.Path [lenPath:]
	 पी, इरेट: = लोडपेज (शीर्षक)
	 अगर गलत है! = nil {
		 p = & पृष्ठ {शीर्षक: शीर्षक}
	 }
	 t, _: = template.ParseFile ("edit.html", nil)
	 t.Execute (पी, डब्ल्यू)
 } 

Template.ParseFile विधि edit.html फ़ाइल को पढ़ेगी और टाइप * value.Template का मान लौटाएगी ।

T.Execute पद्धति p.title और p.body के मानों के साथ {title} और {body} की सभी घटनाओं को प्रतिस्थापित करती है , और परिणामी HTML को http.esponseWriter के एक वेरिएबल में आउटपुट करती है।

ध्यान दें कि टेम्पलेट {body | html} टेम्पलेट में सामने आया था । इसका मतलब है कि पैरामीटर को HTML में आउटपुट के लिए स्वरूपित किया जाएगा, अर्थात। बच जाएगा और, उदाहरण के लिए, > द्वारा प्रतिस्थापित किया जाएगा & gt; । यह फ़ॉर्म में डेटा को सही ढंग से प्रदर्शित करेगा।

अब प्रोग्राम में fmt.Sprintf के लिए कोई कॉल नहीं है, आप आयात से fmt निकाल सकते हैं।

हम पृष्ठ प्रदर्शित करने के लिए एक खाका भी बनाते हैं।

  <h1> {शीर्षक} </ h1>
 <p> [<a href="/edit/unningtitlele""> संपादित करें </a>] </ p>
 <div> {body} </ div> 

तदनुसार व्यूहलर बदलें:

  func viewHandler (डब्ल्यू http.esponseWriter, आर * http.Request) {
	 शीर्षक: = r.URL.Path [lenPath:]
	 पी, _: = लोडपेज (शीर्षक)
	 t, _: = template.ParseFile ("view.html", nil)
	 t.Execute (पी, डब्ल्यू)
 } 

ध्यान दें कि कॉलिंग टेम्प्लेट का कोड दोनों मामलों में लगभग समान है। हम इस कोड को एक अलग फ़ंक्शन में ले जाकर दोहराव से छुटकारा पाएँगे:

  func viewHandler (डब्ल्यू http.esponseWriter, आर * http.Request) {
	 शीर्षक: = r.URL.Path [lenPath:]
	 पी, _: = लोडपेज (शीर्षक)
	 रेंडरटेम्पलेट (डब्ल्यू, "व्यू", पी)
 }
 func editHandler (w http.ResponseWriter, r * http.Request) {
	 शीर्षक: = r.URL.Path [lenPath:]
	 पी, इरेट: = लोडपेज (शीर्षक)
	 अगर गलत है! = nil {
		 p = & पृष्ठ {शीर्षक: शीर्षक}
	 }
	 रेंडरटेम्पलेट (डब्ल्यू, "एडिट", पी)
 }
 func renderTemplate (w http.ResponseWriter, tmpl string, p * पेज) {
	 t, _: = template.ParseFile (tmpl + "। html", nil)
	 t.Execute (पी, डब्ल्यू)
 } 

हैंडलर अब छोटे और सरल हो गए हैं।

गुम पृष्ठों को संभालना

जब आप / view / APageThatDoesntExist पर जाते हैं तो क्या होता है? कार्यक्रम गिर जाएगा। और सभी क्योंकि हमने लोडपेज द्वारा लौटाए गए दूसरे मूल्य को संसाधित नहीं किया है। यदि पृष्ठ मौजूद नहीं है, तो हम एक नया लेख बनाने के लिए उपयोगकर्ता को पृष्ठ पर पुनर्निर्देशित करेंगे:

  func viewHandler (डब्ल्यू http.ResponseWriter, आर * http.Request, शीर्षक स्ट्रिंग) {
	 पी, इरेट: = लोडपेज (शीर्षक)
	 अगर गलत है! = nil {
		 http.Redirect (w, r, "/ edit /" + शीर्षक, http.StatusFound)
		 वापसी
	 }
	 रेंडरटेम्पलेट (डब्ल्यू, "व्यू", पी)
 } 

HTTP.Redirect फ़ंक्शन HTTP स्थिति HTTP.StatusFound (302) और स्थान शीर्ष लेख को HTTP प्रतिक्रिया में जोड़ता है।

सेविंग पेज

SaveHandler फ़ंक्शन डेटा को प्रपत्र से संसाधित करता है।

  func saveHandler (w http.ResponseWriter, r * http.Request) {
	 शीर्षक: = r.URL.Path [lenPath:]
	 शरीर: = r.FormValue ("शरीर")
	 p: = & पेज {शीर्षक: शीर्षक, निकाय: [] बाइट (शरीर)}
	 पी। सेवे ()
	 http.Redirect (w, r, "/ दृश्य /" + शीर्षक, http.StatusFound)
 } 

चयनित सुरक्षा और निकाय के साथ एक नया पृष्ठ बनाया जाता है। सहेजें () विधि डेटा को एक फ़ाइल में सहेजती है, क्लाइंट को / दृश्य / पृष्ठ पर पुनर्निर्देशित किया जाता है।

FormValue द्वारा दिया गया मान टाइप स्ट्रिंग का है । इसे पृष्ठ संरचना में सहेजने के लिए, हम इसे [] बाइट लिखकर [] बाइट (शरीर) में परिवर्तित करते हैं।

हैंडलिंग में त्रुटि

हम अपने कार्यक्रम में कई स्थानों पर त्रुटियों को अनदेखा करते हैं। यह इस तथ्य की ओर जाता है कि त्रुटि होने पर प्रोग्राम क्रैश हो जाता है, इसलिए उपयोगकर्ता को एक त्रुटि संदेश वापस करना बेहतर होता है, जबकि सर्वर काम करना जारी रखेगा।

पहले, रेंडर करने में त्रुटि हैंडलिंग जोड़ें

  func renderTemplate (w http.ResponseWriter, tmpl string, p * पेज) {
	 t, इरेट: = template.ParseFile (tmpl + "। html", nil)
	 अगर गलत है! = nil {
		 http.Error (w, इरेटी। स्ट्रिंग (), http.StatusInternalServerError)
		 वापसी
	 }
	 तक = t.Execute (p, w)
	 अगर गलत है! = nil {
		 http.Error (w, इरेटी। स्ट्रिंग (), http.StatusInternalServerError)
	 }
 } 

Http.Error फ़ंक्शन चयनित HTTP स्थिति (इस मामले में, "आंतरिक सर्वर त्रुटि") भेजता है और एक त्रुटि संदेश देता है।

आइए saveHandler में एक समान संपादन करें:

  func saveHandler (डब्ल्यू http.ResponseWriter, आर * http.Request, शीर्षक स्ट्रिंग) {
	 शरीर: = r.FormValue ("शरीर")
	 p: = & पेज {शीर्षक: शीर्षक, निकाय: [] बाइट (शरीर)}
	 ग़लती से: = p.save ()
	 अगर गलत है! = nil {
		 http.Error (w, इरेटी। स्ट्रिंग (), http.StatusInternalServerError)
		 वापसी
	 }
	 http.Redirect (w, r, "/ दृश्य /" + शीर्षक, http.StatusFound)
 } 

P.save () में होने वाली कोई भी त्रुटि उपयोगकर्ता को दी जाएगी।

टेम्पलेट कैशिंग

हमारा कोड पर्याप्त कुशल नहीं है: रेंडरटेम्पलेट हर बार किसी पृष्ठ के रेंडर होने पर ParseFile कॉल करता है। कार्यक्रम के स्टार्टअप पर प्रत्येक टेम्पलेट के लिए एक बार ParseFile को कॉल करना बेहतर है, भविष्य के उपयोग के लिए एक संरचना में * टेम्पलेट प्रकार के प्राप्त मूल्यों को सहेजना।

सबसे पहले, एक टेम्प्लेट का नक्शा बनाएं, जिसमें हम * टेम्पलेट के मानों को सहेजते हैं, मैप में कुंजी टेम्पलेट का नाम होगा:

  var टेम्पलेट्स = make (नक्शा [स्ट्रिंग] * टेम्पलेट ।emplate) 

अगला, हम एक इनिशियलाइज़ेशन फंक्शन बनाएंगे, जिसे हम मेन () से पहले कॉल करेंगे। टेम्पलेट । MustParseFile फ़ंक्शन ParseFile के लिए एक आवरण है जो त्रुटि कोड नहीं लौटाता है, इसके बजाय, यह पैनिक करता है। वास्तव में, यह व्यवहार कार्यक्रम के लिए स्वीकार्य है, क्योंकि यह ज्ञात नहीं है कि गलत टेम्पलेट को कैसे संसाधित किया जाए।

  func init () {for _, tmpl: = range [] string {"edit", "view"} {टेम्पलेट्स [tmpl] = template.MustParseFile (tmpl + "। html", nil)}}। 

लूप के लिए रेंज निर्माण के साथ प्रयोग किया जाता है और दिए गए पैटर्न को संसाधित करता है।

इसके बाद, रेंडरटेम्पलेट फ़ंक्शन को बदलें ताकि वह संबंधित टेम्प्लेट की एक्सक्यूट विधि को कॉल करे :

  func renderTemplate (w http.ResponseWriter, tmpl string, p * पेज) {
	 गलत: = टेम्पलेट्स [tmpl]। निष्पादित (पी, डब्ल्यू)
	 अगर गलत है! = nil {
		 http.Error (w, इरेटी। स्ट्रिंग (), http.StatusInternalServerError)
	 }
 } 

मान्यता

जैसा कि पहले ही उल्लेख किया गया है, हमारे कार्यक्रम में गंभीर सुरक्षा त्रुटियां हैं। एक नाम के बजाय, आप एक मनमाना मार्ग पारित कर सकते हैं। एक नियमित अभिव्यक्ति जाँच जोड़ें।

Regexp लाइब्रेरी आयात करें। एक वैश्विक वैरिएबल बनाएं जिसमें हम अपने आरवी को बचाते हैं:

  var titleValidator = regexp.MustCompile ("^ [a-zA-Z0-9] [$") 

Regexp.MustCompile फ़ंक्शन नियमित अभिव्यक्ति संकलित करता है और regexp.Regexp देता है। MustCompile , टेम्पलेट की तरह। MustParseFile , Compile से इस बात में भिन्न है कि यह त्रुटि की स्थिति में है, जबकि Compile एक त्रुटि कोड देता है।

अब, URL से शीर्षक निकालने वाले एक फ़ंक्शन का निर्माण करते हैं, और उसके PB शीर्षक को जांचते हैं :

  func getTitle (डब्ल्यू http.ResponseWriter, आर * http.Request) (शीर्षक स्ट्रिंग, इर ओएस के आधार पर) {
	 शीर्षक = r.URL.Path [lenPath:]
	 if! titleValidator.MatchString (शीर्षक) {
		 http.NotFound (w, r)
		 गलत = os.NewError ("अमान्य पृष्ठ शीर्षक")
	 }
	 वापसी
 } 

यदि शीर्षक सही है, तो उसके साथ शून्य वापस कर दिया जाएगा। अन्यथा, "404 नहीं मिला" उपयोगकर्ता को प्रदर्शित किया जाएगा, और एक त्रुटि हैंडलर को वापस कर दी जाएगी।

प्रत्‍येक हैंडलर को गेटलिटल कॉल जोड़ें:

  func viewHandler (डब्ल्यू http.esponseWriter, आर * http.Request) {
	 शीर्षक, गलत: = getTitle (w, r)
	 अगर गलत है! = nil {
		 वापसी
	 }
	 पी, इरेट: = लोडपेज (शीर्षक)
	 अगर गलत है! = nil {
		 http.Redirect (w, r, "/ edit /" + शीर्षक, http.StatusFound)
		 वापसी
	 }
	 रेंडरटेम्पलेट (डब्ल्यू, "व्यू", पी)
 }
 func editHandler (w http.ResponseWriter, r * http.Request) {
	 शीर्षक, गलत: = getTitle (w, r)
	 अगर गलत है! = nil {
		 वापसी
	 }
	 पी, इरेट: = लोडपेज (शीर्षक)
	 अगर गलत है! = nil {
		 p = & पृष्ठ {शीर्षक: शीर्षक}
	 }
	 रेंडरटेम्पलेट (डब्ल्यू, "एडिट", पी)
 }
 func saveHandler (w http.ResponseWriter, r * http.Request) {
	 शीर्षक, गलत: = getTitle (w, r)
	 अगर गलत है! = nil {
		 वापसी
	 }
	 शरीर: = r.FormValue ("शरीर")
	 p: = & पेज {शीर्षक: शीर्षक, निकाय: [] बाइट (शरीर)}
	 तक = p.save ()
	 अगर गलत है! = nil {
		 http.Error (w, इरेटी। स्ट्रिंग (), http.StatusInternalServerError)
		 वापसी
	 }
	 http.Redirect (w, r, "/ दृश्य /" + शीर्षक, http.StatusFound)
 } 

कार्यात्मक प्रकार और क्लोजर

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

हम शीर्षक पैरामीटर को जोड़कर हैंडलर को फिर से लिखते हैं:

  func viewHandler (w http.ResponseWriter, r * http.Request, शीर्षक स्ट्रिंग)
 func editHandler (डब्ल्यू http.esponseWriter, आर * http.Request, शीर्षक स्ट्रिंग)
 func saveHandler (w http.ResponseWriter, r * http.Request, शीर्षक स्ट्रिंग) 

अब हम एक रैपर फ़ंक्शन को परिभाषित करते हैं जो ऊपर परिभाषित फ़ंक्शन को लेता है और http.HandlerFunc (इसे http.HandleFunc को पास करने के लिए) लौटाता है :

  func makeHandler (fn func (http.ResponseWriter, * http.Request, string)) http.HandlerFunc {
	 वापसी func (w http.ResponseWriter, आर * http.Request) {
		 // यहाँ हम अनुरोध से पृष्ठ का शीर्षक निकालेंगे,
		 // और उपलब्ध हैंडलर 'fn' को कॉल करें
	 }
 } 

लौटाया गया फ़ंक्शन एक क्लोजर है, क्योंकि इसके बाहर परिभाषित मूल्यों का उपयोग करता है (इस मामले में, चर fn , हैंडलर)।

कोड को गेटलिटल से यहां ले जाएं :

  func makeHandler (fn func (http.ResponseWriter, * http.Request, string)) http.HandlerFunc {
	 वापसी func (w http.ResponseWriter, आर * http.Request) {
		 शीर्षक: = r.URL.Path [lenPath:]
		 if! titleValidator.MatchString (शीर्षक) {
			 http.NotFound (w, r)
			 वापसी
		 }
		 fn (डब्ल्यू, आर, शीर्षक)
	 }
 } 

मेकहैंडलर द्वारा दिया गया क्लोजर एक ऐसा फंक्शन है, जो http.ResponseWriter और http.Request (जैसे, http.HandlerFunc जैसे फंक्शन) जैसे मापदंडों को लेता है। यह क्लोजर URL से शीर्षक निकालता है और इसके PB टाइटलवीडिएटर को चेक करता है। यदि शीर्ष लेख गलत है, तो एक त्रुटि ResponseWriter ( http.NotFound कॉल करें) को भेजी जाएगी। अन्यथा, इसी fn हैंडलर को बुलाया जाएगा।

मुख्य () फ़ंक्शन के लिए एक आवरण कॉल जोड़ें:

  दुर्गंध मुख्य () {
	 http.HandleFunc ("/ view /", makeHandler (viewHandler))
	 http.HandleFunc ("/ edit /", makeHandler (editHandler))
	 http.andleFunc ("/ save /", makeHandler (saveHandler))
	 http.ListenAndServe (": 8080", नील)
 } 

अंत में हम हैंडलर फ़ंक्शंस से आने वाले कॉल को हटा देते हैं, जिससे वे बहुत सरल हो जाते हैं:

  func viewHandler (डब्ल्यू http.ResponseWriter, आर * http.Request, शीर्षक स्ट्रिंग) {
	 पी, इरेट: = लोडपेज (शीर्षक)
	 अगर गलत है! = nil {
		 http.Redirect (w, r, "/ edit /" + शीर्षक, http.StatusFound)
		 वापसी
	 }
	 रेंडरटेम्पलेट (डब्ल्यू, "व्यू", पी)
 }

 func editHandler (डब्ल्यू http.ResponseWriter, आर * http.Request, शीर्षक स्ट्रिंग) {
	 पी, इरेट: = लोडपेज (शीर्षक)
	 अगर गलत है! = nil {
		 p = & पृष्ठ {शीर्षक: शीर्षक}
	 }
	 रेंडरटेम्पलेट (डब्ल्यू, "एडिट", पी)
 }

 func saveHandler (डब्ल्यू http.ResponseWriter, आर * http.Request, शीर्षक स्ट्रिंग) {
	 शरीर: = r.FormValue ("शरीर")
	 p: = & पेज {शीर्षक: शीर्षक, निकाय: [] बाइट (शरीर)}
	 ग़लती से: = p.save ()
	 अगर गलत है! = nil {
		 http.Error (w, इरेटी। स्ट्रिंग (), http.StatusInternalServerError)
		 वापसी
	 }
	 http.Redirect (w, r, "/ दृश्य /" + शीर्षक, http.StatusFound)
 } 

इसी में परिणाम होना चाहिए

हम कोड का पुनर्निर्माण करते हैं और अपना आवेदन चलाते हैं:

 $ 8g wiki.go
 $ 8 एल विकी ।8
 $ ./8.out

Http: // localhost: 8080 / view / ANewPage में फॉर्म के साथ एक पेज होगा। आप पृष्ठ को सहेज सकते हैं और उस पर जा सकते हैं।

नोट। कोडर में textarea को तोड़ा जाना था ताकि habraparser को संक्रमित न किया जा सके।