गो का उपयोग करके अपना पहला वेब एप्लिकेशन कैसे बनाएं

नमस्कार, हेब्र! मैं आपके लिए अयूलुवा यशायाह के लेख "गो के साथ अपना पहला वेब एप्लिकेशन कैसे बनाऊं" का अनुवाद प्रस्तुत करता हूं।

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

आप इस GitHub रिपॉजिटरी में इस ट्यूटोरियल के लिए उपयोग किया गया पूरा कोड पा सकते हैं।

आवश्यकताओं

इस कार्य के लिए एकमात्र आवश्यकता यह है कि गो आपके कंप्यूटर पर स्थापित है और आप इसके सिंटैक्स और निर्माणों से थोड़ा परिचित हैं। गो संस्करण जिसे मैंने एप्लिकेशन बनाने के लिए उपयोग किया था, वह लेखन के समय भी नवीनतम है: 1.12.9 । गो के स्थापित संस्करण को देखने के लिए, गो go version कमांड का उपयोग करें।

यदि आपको यह कार्य बहुत कठिन लगता है, तो मेरे पिछले परिचयात्मक भाषा पाठ पर जाएं , जिससे आपको आरंभ करने में मदद मिलनी चाहिए।

तो चलिए शुरू करते है!

हम निर्मित निर्देशिका में GitHub और cd पर आरंभिक फाइल रिपॉजिटरी को क्लोन करते हैं । हमारे पास तीन मुख्य फाइलें हैं: main.go फाइल में main.go हम इस कार्य के लिए सभी गो कोड लिखेंगे। index.html फ़ाइल वह टेम्प्लेट है जो ब्राउज़र को भेजा जाएगा, और एप्लिकेशन के लिए assets/styles.css ।

एक बेसिक वेब सर्वर बनाएं

चलो एक मूल सर्वर बनाने से शुरू होता है जो सर्वर को GET अनुरोध निष्पादित करते समय ब्राउज़र को "हैलो वर्ल्ड!" पाठ भेजता है। इस तरह दिखने के लिए अपनी main.go फाइल बदलें:

 package main import ( "net/http" "os" ) func indexHandler(w http.ResponseWriter, r *http.Request) { w.Write([]byte("<h1>Hello World!</h1>")) } func main() { port := os.Getenv("PORT") if port == "" { port = "3000" } mux := http.NewServeMux() mux.HandleFunc("/", indexHandler) http.ListenAndServe(":"+port, mux) } 

package main की पहली पंक्ति - घोषणा करती है कि main.go फ़ाइल में कोड मुख्य पैकेज का है। उसके बाद, हमने net/http पैकेज का आयात किया, जो हमारे आवेदन में उपयोग के लिए HTTP क्लाइंट और सर्वर कार्यान्वयन प्रदान करता है। यह पैकेज मानक पुस्तकालय का हिस्सा है और प्रत्येक गो स्थापना के साथ शामिल है।

main फ़ंक्शन में, http.NewServeMux() एक नया HTTP अनुरोध मल्टीप्लेक्स बनाता है और इसे mux वेरिएबल में असाइन करता है। अनिवार्य रूप से, अनुरोध मल्टीप्लेक्स पंजीकृत पथों की सूची में आने वाले अनुरोधों के URL से मेल खाता है और जब भी कोई मैच मिलता है, तो पथ के लिए उपयुक्त हैंडलर को कॉल करता है।

अगला, हम रूट पथ / लिए अपना पहला हैंडलर फ़ंक्शन पंजीकृत करते हैं। यह हैंडलर फंक्शन हैंडल का दूसरा तर्क है और हमेशा सिग्नेचर func (w http.ResponseWriter, r * http.Request) ।

यदि आप indexHandler फ़ंक्शन को देखते हैं, तो आप देखेंगे कि इसमें केवल एक हस्ताक्षर है, जो इसे HandleFunc लिए एक वैध दूसरा तर्क HandleFunc । w पैरामीटर वह संरचना है जिसका उपयोग हम HTTP अनुरोध के जवाब भेजने के लिए करते हैं। यह Write() विधि को लागू करता है, जो बाइट स्लाइस लेता है और संयुक्त डेटा को HTTP प्रतिक्रिया के भाग के रूप में लिखता है।

दूसरी ओर, पैरामीटर r क्लाइंट से प्राप्त HTTP अनुरोध का प्रतिनिधित्व करता है। यह है कि हम वेब ब्राउज़र द्वारा सर्वर पर भेजे गए डेटा तक कैसे पहुंचते हैं। हम इसे अभी तक यहां उपयोग नहीं कर रहे हैं, लेकिन हम बाद में इसका उपयोग जरूर करेंगे।

अंत में, हमारे पास http.ListenAndServe() विधि है, जो कि पोर्ट 3000 को सर्वर पर शुरू करता है यदि पोर्ट पर्यावरण द्वारा सेट नहीं किया गया है। यदि आपके कंप्यूटर पर 3000 का उपयोग किया जाता है, तो एक अलग पोर्ट का उपयोग करने के लिए स्वतंत्र महसूस करें।

फिर आपके द्वारा लिखे गए कोड को संकलित करें और निष्पादित करें:

 go run main.go 

यदि आप अपने ब्राउज़र में http: // localhost: 3000 पर जाते हैं, तो आपको "हैलो वर्ल्ड!" पाठ देखना चाहिए।

टेम्प्लेट जाएं

आइए देखें गो में टेंपलेटिंग की मूल बातें। यदि आप अन्य भाषाओं के टेम्प्लेट से परिचित हैं, तो इसे समझना आसान होना चाहिए।

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

जाओ अपने मानक पुस्तकालय में दो टेम्पलेट पुस्तकालय प्रदान करता है: text/template और html/template । दोनों एक ही इंटरफ़ेस प्रदान करते हैं, हालांकि HTML आउटपुट उत्पन्न करने के लिए html/template पैकेज का उपयोग किया जाता है जो कोड इंजेक्शन के विरुद्ध सुरक्षित है, इसलिए हम इसका उपयोग यहां करेंगे।

इस पैकेज को अपनी main.go फ़ाइल में आयात करें और निम्नानुसार उपयोग करें:

 package main import ( "html/template" "net/http" "os" ) var tpl = template.Must(template.ParseFiles("index.html")) func indexHandler(w http.ResponseWriter, r *http.Request) { tpl.Execute(w, nil) } func main() { port := os.Getenv("PORT") if port == "" { port = "3000" } mux := http.NewServeMux() mux.HandleFunc("/", indexHandler) http.ListenAndServe(":"+port, mux) } 

tpl एक पैकेज स्तर चर है जो प्रदान की गई फ़ाइलों से टेम्पलेट की परिभाषा को इंगित करता है। Template.ParseFiles कॉल हमारे प्रोजेक्ट डायरेक्टरी की जड़ में index.html फ़ाइल को पार्स करता है और इसकी वैधता की जांच करता है।

हम template.ParseFiles को template.ParseFiles लपेटते हैं। केवल इसलिए कि जब त्रुटि होती है तो कोड आतंक का कारण बनता है। त्रुटि को संभालने की कोशिश करने के बजाय हम यहां घबराते हैं क्योंकि यह कोड को निष्पादित करने का कोई मतलब नहीं रखता है अगर हमारे पास एक अवैध टेम्पलेट है। यह एक समस्या है जिसे सर्वर को पुनः आरंभ करने से पहले ठीक करने की आवश्यकता है।

indexHandler फ़ंक्शन में indexHandler हम दो तर्क प्रदान करके पहले बनाए गए टेम्पलेट को निष्पादित करते हैं: जहां हम आउटपुट और उस डेटा को लिखना चाहते हैं जिसे हम टेम्पलेट में पास करना चाहते हैं।

उपरोक्त मामले में, हम ResponseWriter इंटरफ़ेस को आउटपुट लिखते हैं और, चूंकि हमारे पास अपने टेम्पलेट को पास करने के लिए कोई डेटा नहीं है, इसलिए nil को दूसरे तर्क के रूप में पारित किया गया है।

Ctrl-C का उपयोग करके अपने टर्मिनल में चल रही प्रक्रिया को बंद करें और इसे go run main.go साथ फिर से शुरू करें, फिर अपने ब्राउज़र को ताज़ा करें। आपको नीचे दिखाए गए पेज पर "न्यूज़ ऐप डेमो" टेक्स्ट देखना चाहिए:

पेज पर एक नेविगेशन बार जोड़ें

नीचे दिखाए अनुसार अपनी index.html फ़ाइल में <body> की सामग्री को बदलें:

 <main> <header> <a class="logo" href="/">News Demo</a> <form action="/search" method="GET"> <input autofocus class="search-input" value="" placeholder="Enter a news topic" type="search" name="q"> </form> <a href="https://github.com/freshman-tech/news" class="button github-button">View on Github</a> </header> </main> 

फिर सर्वर को रिबूट करें और अपने ब्राउज़र को ताज़ा करें। आपको इसके समान कुछ देखना चाहिए:

स्थिर फ़ाइलों के साथ काम करें

कृपया ध्यान दें कि हमने जो नेविगेशन बार जोड़ा है उसमें शैलियों नहीं है, इस तथ्य के बावजूद कि हमने पहले से ही उन्हें हमारे दस्तावेज़ के <head> में निर्दिष्ट किया है।

ऐसा इसलिए है क्योंकि पथ / वास्तव में उन सभी रास्तों से मेल खाता है जो अन्यत्र संसाधित नहीं होते हैं। इसलिए, यदि आप http: // लोकलहोस्ट: 3000 / एसेट्स / स्टाइल.सीएसएस पर जाते हैं , तो आपको अभी भी सीएसएस फाइल के बजाय न्यूज डेमो होमपेज मिलेगा क्योंकि रूट /assets/style.css विशेष रूप से घोषित नहीं किया गया है।

लेकिन हमारी सभी स्टैटिक फ़ाइलों के लिए स्पष्ट हैंडलर घोषित करने की आवश्यकता अवास्तविक है और कोई पैमाना नहीं हो सकता। सौभाग्य से, हम सभी स्थिर संसाधनों की सेवा के लिए एक हैंडलर बना सकते हैं।

पहली बात यह है कि फ़ाइल सर्वर ऑब्जेक्ट का एक उदाहरण बनाना है, उस निर्देशिका में गुजरना जिसमें हमारी सभी स्थिर फाइलें स्थित हैं:

 fs := http.FileServer(http.Dir("assets")) 

इसके बाद, हमें अपने राउटर को इस फाइल सर्वर ऑब्जेक्ट को /assets/ प्रीफिक्स के साथ शुरू होने वाले सभी रास्तों का उपयोग करने के लिए बताना होगा:

 mux.Handle("/assets/", http.StripPrefix("/assets/", fs)) 

अब सभी एक साथ:

 // main.go //   func main() { port := os.Getenv("PORT") if port == "" { port = "3000" } mux := http.NewServeMux() //     fs := http.FileServer(http.Dir("assets")) mux.Handle("/assets/", http.StripPrefix("/assets/", fs)) mux.HandleFunc("/", indexHandler) http.ListenAndServe(":"+port, mux) } 

सर्वर को रीबूट करें और ब्राउज़र को रिफ्रेश करें। नीचे दी गई शैलियों को चालू करना चाहिए:

हम एक मार्ग / खोज बनाते हैं

आइए एक मार्ग बनाएं जो समाचार लेखों के लिए खोज प्रश्नों को संभालता है। हम अनुरोधों को संसाधित करने के लिए समाचार एपीआई का उपयोग करेंगे, इसलिए आपको यहां मुफ्त एपीआई कुंजी प्राप्त करने के लिए पंजीकरण करने की आवश्यकता है ।

यह मार्ग दो क्वेरी मापदंडों की अपेक्षा करता है: q उपयोगकर्ता की क्वेरी का प्रतिनिधित्व करता है, और परिणाम के माध्यम से स्क्रॉल करने के लिए page उपयोग किया जाता है। यह page पैरामीटर वैकल्पिक है। यदि यह URL में शामिल नहीं है, तो हम बस यह मान लेते हैं कि परिणामों की पृष्ठ संख्या "1" पर सेट है।

indexHandler तहत निम्नलिखित हैंडलर को अपनी main.go फ़ाइल में जोड़ें:

 func searchHandler(w http.ResponseWriter, r *http.Request) { u, err := url.Parse(r.URL.String()) if err != nil { w.WriteHeader(http.StatusInternalServerError) w.Write([]byte("Internal server error")) return } params := u.Query() searchKey := params.Get("q") page := params.Get("page") if page == "" { page = "1" } fmt.Println("Search Query is: ", searchKey) fmt.Println("Results page is: ", page) } 

उपरोक्त कोड अनुरोध URL से q और page पैरामीटर निकालता है और टर्मिनल में दोनों को प्रदर्शित करता है।

फिर searchHandler फ़ंक्शन को /search पथ हैंडलर के रूप में पंजीकृत करें, जैसा कि नीचे दिखाया गया है:

 func main() { port := os.Getenv("PORT") if port == "" { port = "3000" } mux := http.NewServeMux() fs := http.FileServer(http.Dir("assets")) mux.Handle("/assets/", http.StripPrefix("/assets/", fs)) // Add the next line mux.HandleFunc("/search", searchHandler) mux.HandleFunc("/", indexHandler) http.ListenAndServe(":"+port, mux) } 

ऊपर से fmt और net/url संकुल आयात करना याद रखें:

 import ( "fmt" "html/template" "net/http" "net/url" "os" ) 

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

एक डेटा मॉडल बनाएँ

जब हम News API/everything समापन बिंदु के लिए एक अनुरोध करते हैं, तो हम निम्नलिखित प्रारूप में एक प्रतिक्रिया की उम्मीद करते हैं:

 { "status": "ok", "totalResults": 4661, "articles": [ { "source": { "id": null, "name": "Gizmodo.com" }, "author": "Jennings Brown", "title": "World's Dumbest Bitcoin Scammer Tries to Scam Bitcoin Educator, Gets Scammed in The Process", "description": "Ben Perrin is a Canadian cryptocurrency enthusiast and educator who hosts a bitcoin show on YouTube. This is immediately apparent after a quick a look at all his social media. Ten seconds of viewing on of his videos will show that he is knowledgeable about di…", "url": "https://gizmodo.com/worlds-dumbest-bitcoin-scammer-tries-to-scam-bitcoin-ed-1837032058", "urlToImage": "https://i.kinja-img.com/gawker-media/image/upload/s--uLIW_Oxp--/c_fill,fl_progressive,g_center,h_900,q_80,w_1600/s4us4gembzxlsjrkmnbi.png", "publishedAt": "2019-08-07T16:30:00Z", "content": "Ben Perrin is a Canadian cryptocurrency enthusiast and educator who hosts a bitcoin show on YouTube. This is immediately apparent after a quick a look at all his social media. Ten seconds of viewing on of his videos will show that he is knowledgeable about..." } ] } 

गो में इस डेटा के साथ काम करने के लिए, हमें एक संरचना तैयार करनी होगी जो प्रतिक्रिया शरीर को डिकोड करते समय डेटा को दर्शाती है। बेशक, आप इसे मैन्युअल रूप से कर सकते हैं, लेकिन मैं JSON-to-Go वेबसाइट का उपयोग करना पसंद करता हूं, जो इस प्रक्रिया को वास्तव में आसान बनाता है। यह एक गो संरचना (टैग के साथ) उत्पन्न करता है जो इस JSON के लिए काम करेगा।

आपको बस JSON ऑब्जेक्ट को कॉपी करना है और इसे JSON के साथ चिह्नित फ़ील्ड में पेस्ट करना है, फिर आउटपुट कॉपी करें और इसे अपने कोड में पेस्ट करें। यहां हमें उपरोक्त JSON ऑब्जेक्ट के लिए क्या मिलेगा:

 type AutoGenerated struct { Status string `json:"status"` TotalResults int `json:"totalResults"` Articles []struct { Source struct { ID interface{} `json:"id"` Name string `json:"name"` } `json:"source"` Author string `json:"author"` Title string `json:"title"` Description string `json:"description"` URL string `json:"url"` URLToImage string `json:"urlToImage"` PublishedAt time.Time `json:"publishedAt"` Content string `json:"content"` } `json:"articles"` } 

मैंने अपने स्वयं के ढांचे में Articles टुकड़े को अलग करके और संरचना के नाम को अपडेट करके AutoGenerated संरचना में कई बदलाव किए हैं। निम्नलिखित main.go चर घोषणा main.go में main.go और अपने आयात में time पैकेज जोड़ें:

 type Source struct { ID interface{} `json:"id"` Name string `json:"name"` } type Article struct { Source Source `json:"source"` Author string `json:"author"` Title string `json:"title"` Description string `json:"description"` URL string `json:"url"` URLToImage string `json:"urlToImage"` PublishedAt time.Time `json:"publishedAt"` Content string `json:"content"` } type Results struct { Status string `json:"status"` TotalResults int `json:"totalResults"` Articles []Article `json:"articles"` } 

जैसा कि आप जानते हैं, गो को यह आवश्यक है कि संरचना में सभी निर्यातित फ़ील्ड एक बड़े अक्षर से शुरू होते हैं। हालाँकि, यह JSON फ़ील्ड्स का प्रतिनिधित्व करने के लिए प्रथागत है, जो CamelCase या snake_case का उपयोग कर रहा है , जो कि बड़े अक्षर से शुरू नहीं होता है।

इसलिए, हम संरचना फ़ील्ड टैग जैसे कि json:"id" का उपयोग स्पष्ट रूप से JSON फ़ील्ड में संरचना फ़ील्ड प्रदर्शित करने के लिए करते हैं, जैसा कि ऊपर दिखाया गया है। यदि आवश्यक हो, तो यह आपको संरचना क्षेत्र और संबंधित जोन क्षेत्र के लिए पूरी तरह से अलग नामों का उपयोग करने की अनुमति भी देता है।

अंत में, आइए प्रत्येक खोज क्वेरी के लिए एक अलग प्रकार की संरचना बनाएं। मुख्य संरचना में Results संरचना के नीचे इसे जोड़ें:

 type Search struct { SearchKey string NextPage int TotalPages int Results Results } 

यह संरचना उपयोगकर्ता द्वारा बनाई गई प्रत्येक खोज क्वेरी का प्रतिनिधित्व करती है। SearchKey स्वयं क्वेरी है, NextPage फ़ील्ड NextPage परिणामों के माध्यम से स्क्रॉल करने की अनुमति देती है, TotalPages - क्वेरी परिणामों के कुल पृष्ठ और Results - क्वेरी परिणामों के वर्तमान पृष्ठ।

समाचार एपीआई का उपयोग करके एक अनुरोध भेजें और परिणाम प्रस्तुत करें

अब जब हमारे पास हमारे आवेदन के लिए डेटा मॉडल है, तो चलें जारी रखें और समाचार एपीआई से अनुरोध करें, और फिर पृष्ठ पर परिणाम प्रस्तुत करें।

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

सबसे पहले apiKey वैरिएबल के तहत एक नया apiKey वेरिएबल घोषित करें:

 var apiKey *string 

फिर इसे निम्न प्रकार से main कार्य में उपयोग करें:

 func main() { apiKey = flag.String("apikey", "", "Newsapi.org access key") flag.Parse() if *apiKey == "" { log.Fatal("apiKey must be set") } //    } 

यहां हम ध्वज कहते हैं। स्ट्रिंग flag.String() विधि, जो हमें एक स्ट्रिंग ध्वज को परिभाषित करने की अनुमति देती है। इस पद्धति का पहला तर्क ध्वज नाम है, दूसरा डिफ़ॉल्ट मान है, और तीसरा उपयोग विवरण है।

सभी झंडे को परिभाषित करने के बाद, आपको ध्वज को कॉल करने की आवश्यकता है। flag.Parse() वास्तव में उन्हें flag.Parse() करने के लिए। अंत में, चूंकि apikey इस एप्लिकेशन के लिए एक आवश्यक घटक है, हम यह सुनिश्चित करते हैं कि यदि प्रोग्राम फ्लैग को प्रोग्राम के निष्पादन के दौरान सेट नहीं किया गया है तो प्रोग्राम क्रैश हो जाता है।

सुनिश्चित करें कि आप अपने आयात में flag पैकेज को जोड़ते हैं, फिर सर्वर को पुनरारंभ करें और आवश्यक apikey ध्वज को पास करें, जैसा कि नीचे दिखाया गया है:

 go run main.go -apikey=<your newsapi access key> 

अगला, आइए searchHandler जारी रखें और अपडेट searchHandler ताकि उपयोगकर्ता की खोज क्वेरी newsapi.org पर भेजी जाए और परिणाम हमारे टेम्पलेट में प्रदर्शित हों।

निम्नलिखित कॉल के साथ दो कॉल को fmt.Println() मेथड में खोजें।

 func searchHandler(w http.ResponseWriter, r *http.Request) { // beginning of the function search := &Search{} search.SearchKey = searchKey next, err := strconv.Atoi(page) if err != nil { http.Error(w, "Unexpected server error", http.StatusInternalServerError) return } search.NextPage = next pageSize := 20 endpoint := fmt.Sprintf("https://newsapi.org/v2/everything?q=%s&pageSize=%d&page=%d&apiKey=%s&sortBy=publishedAt&language=en", url.QueryEscape(search.SearchKey), pageSize, search.NextPage, *apiKey) resp, err := http.Get(endpoint) if err != nil { w.WriteHeader(http.StatusInternalServerError) return } defer resp.Body.Close() if resp.StatusCode != 200 { w.WriteHeader(http.StatusInternalServerError) return } err = json.NewDecoder(resp.Body).Decode(&search.Results) if err != nil { w.WriteHeader(http.StatusInternalServerError) return } search.TotalPages = int(math.Ceil(float64(search.Results.TotalResults / pageSize))) err = tpl.Execute(w, search) if err != nil { w.WriteHeader(http.StatusInternalServerError) } } 

सबसे पहले, हम Search संरचना का एक नया उदाहरण बनाते हैं और SearchKey अनुरोध में URL पैरामीटर q के मान में SearchKey फ़ील्ड का मान सेट करते हैं।

उसके बाद, हम page चर को पूर्णांक में बदलते हैं और परिणाम को search चर के NextPage फ़ील्ड में असाइन करते हैं। तब हम pageSize वैरिएबल बनाते हैं और उसका मान 20 पर सेट करते हैं। यह pageSize वैरिएबल उन परिणामों की संख्या को दर्शाता है, pageSize प्रतिक्रिया में समाचार एपीआई वापस आएगा। यह मान 0 से 100 तक हो सकता है।

फिर हम fmt.Sprintf() का उपयोग करके समापन बिंदु बनाते हैं और इसके लिए एक GET अनुरोध करते हैं। यदि समाचार एपीआई की प्रतिक्रिया 200 ठीक नहीं है, तो हम क्लाइंट को एक सामान्य सर्वर त्रुटि लौटाएंगे। अन्यथा, प्रतिक्रिया निकाय खोज में पार्स किया search.Results ।

तब हम TotalResults फ़ील्ड को pageSize द्वारा विभाजित करके पृष्ठों की कुल संख्या की गणना करते हैं। उदाहरण के लिए, यदि कोई क्वेरी 100 परिणाम देता है, और हम एक बार में केवल 20 देखते हैं, तो हमें उस क्वेरी के सभी 100 परिणामों को देखने के लिए पांच पृष्ठों को स्क्रॉल करना होगा।

उसके बाद, हम अपने टेम्पलेट को प्रस्तुत करते हैं और डेटा इंटरफ़ेस के रूप में search चर को पास करते search । यह हमें हमारे टेम्पलेट में JSON ऑब्जेक्ट से डेटा एक्सेस करने की अनुमति देता है, जैसा कि आप देखेंगे।

index.html पर जाने से पहले, नीचे दिखाए अनुसार अपने आयात को अपडेट करना न भूलें:

 import ( "encoding/json" "flag" "fmt" "html/template" "log" "math" "net/http" "net/url" "os" "strconv" "time" ) 

चलिए जारी करते हैं और पृष्ठ पर परिणाम को प्रदर्शित करते हैं। इसे <header> तहत जोड़ें:

 <section class="container"> <ul class="search-results"> {{ range .Results.Articles }} <li class="news-article"> <div> <a target="_blank" rel="noreferrer noopener" href="{{.URL}}"> <h3 class="title">{{.Title }}</h3> </a> <p class="description">{{ .Description }}</p> <div class="metadata"> <p class="source">{{ .Source.Name }}</p> <time class="published-date">{{ .PublishedAt }}</time> </div> </div> <img class="article-image" src="{{ .URLToImage }}"> </li> {{ end }} </ul> </section> 

टेम्पलेट में संरचना क्षेत्र तक पहुंचने के लिए, हम बिंदु ऑपरेटर का उपयोग करते हैं। यह ऑपरेटर एक संरचना ऑब्जेक्ट (इस मामले में, search ) को संदर्भित करता है, और फिर टेम्पलेट के अंदर हम केवल फ़ील्ड नाम ( {{.Results}} ) निर्दिष्ट करते हैं।

range ब्लॉक हमें गो में एक स्लाइस पर पुनरावृति करने की अनुमति देता है और स्लाइस में प्रत्येक तत्व के लिए कुछ HTML आउटपुट करता है। यहाँ, हम Articles क्षेत्र में निहित Article संरचनाओं के टुकड़े पर पुनरावृत्ति करते हैं और प्रत्येक पुनरावृत्ति पर HTML प्रदर्शित करते हैं।

सर्वर को रिबूट करें, ब्राउज़र को ताज़ा करें और एक लोकप्रिय विषय पर समाचार खोजें। आपको प्रति पृष्ठ 20 परिणामों की एक सूची मिलनी चाहिए, जैसा कि नीचे स्क्रीनशॉट में दिखाया गया है।

विदेशी में खोज क्वेरी सहेजें

ध्यान दें कि जब पृष्ठ परिणामों के साथ ताज़ा हो जाता है तो खोज क्वेरी इनपुट से गायब हो जाती है। आदर्श रूप से, क्वेरी तब तक रखी जानी चाहिए जब तक उपयोगकर्ता एक नई खोज नहीं करता है। उदाहरण के लिए, Google खोज कैसे काम करता है।

हम अपनी index.html फ़ाइल में input टैग के value विशेषता को निम्न प्रकार से आसानी से ठीक कर सकते हैं:

 <input autofocus class="search-input" value="{{ .SearchKey }}" placeholder="Enter a news topic" type="search" name="q"> 

अपने ब्राउज़र को पुनरारंभ करें और एक नई खोज करें। खोज क्वेरी को नीचे दिखाए अनुसार सहेजा जाएगा:

प्रारूप प्रकाशन की तारीख

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

चलिए main.go में Article स्ट्रक्चर के ठीक नीचे निम्नलिखित कोड main.go :

 func (a *Article) FormatPublishedDate() string { year, month, day := a.PublishedAt.Date() return fmt.Sprintf("%v %d, %d", month, day, year) } 

यहां, एक नया FormatPublishedDate विधि Article संरचना में बनाई गई है, और यह विधि Article में FormatPublishedDate फ़ील्ड को प्रारूपित करती है और निम्न प्रारूप में एक स्ट्रिंग लौटाती है: 10 2009 ।

अपने टेम्पलेट में इस नई विधि का उपयोग करने के लिए, अपनी। .FormatPublishedDate फ़ाइल में .PublishedAt साथ। फिर सर्वर को पुनरारंभ करें और पिछली खोज क्वेरी को दोहराएं। यह परिणामों को सही ढंग से स्वरूपित समय के साथ आउटपुट करेगा, जैसा कि नीचे दिखाया गया है:

परिणामों की कुल संख्या प्रदर्शित करें।

आइए पृष्ठ के शीर्ष पर परिणामों की कुल संख्या को इंगित करके हमारे समाचार एप्लिकेशन के उपयोगकर्ता इंटरफ़ेस में सुधार करें, और फिर किसी विशेष क्वेरी के लिए कोई परिणाम नहीं मिलने की स्थिति में एक संदेश प्रदर्शित करें।

आपको बस निम्नलिखित कोड को .container बच्चे के रूप में जोड़ना है, अपनी index.html फ़ाइल में .search-results तत्व के ठीक ऊपर:

 <div class="result-count"> {{ if (gt .Results.TotalResults 0)}} <p>About <strong>{{ .Results.TotalResults }}</strong> results were found.</p> {{ else if (ne .SearchKey "") and (eq .Results.TotalResults 0) }} <p>No results found for your query: <strong>{{ .SearchKey }}</strong>.</p> {{ end }} </div> 

Go , . gt , , TotalResults Results . , .

, SearchKey ( (ne .SearchKey "") ) TotalResults ( (eq .Results.TotalResults 0) ), «No results found».

, . «No results found».

. , :

20 , , .

Next , . , , Search main.go :

 func (s *Search) IsLastPage() bool { return s.NextPage >= s.TotalPages } 

, NextPage , TotalPages Search . , NextPage , . :

 func searchHandler(w http.ResponseWriter, r *http.Request) { //   search.TotalPages = int(math.Ceil(float64(search.Results.TotalResults / pageSize))) //   if  if ok := !search.IsLastPage(); ok { search.NextPage++ } //    } 

, , . .search-results index.html .

 <div class="pagination"> {{ if (ne .IsLastPage true) }} <a href="/search?q={{ .SearchKey }}&page={{ .NextPage }}" class="button next-page">Next</a> {{ end }} </div> 

, Next .

, href /search q , NextPage page .

Previous . , 1. , CurrentPage() Search , . IsLastPage :

 func (s *Search) CurrentPage() int { if s.NextPage == 1 { return s.NextPage } return s.NextPage - 1 } 

NextPage - 1 , , NextPage 1. , 1 . :

 func (s *Search) PreviousPage() int { return s.CurrentPage() - 1 } 

, Previous , 1. .pagination index.html :

 <div class="pagination"> {{ if (gt .NextPage 2) }} <a href="/search?q={{ .SearchKey }}&page={{ .PreviousPage }}" class="button previous-page">Previous</a> {{ end }} {{ if (ne .IsLastPage true) }} <a href="/search?q={{ .SearchKey }}&page={{ .NextPage }}" class="button next-page">Next</a> {{ end }} </div> 

. , :

, , , , .

index.html :

 <div class="result-count"> {{ if (gt .Results.TotalResults 0)}} <p>About <strong>{{ .Results.TotalResults }}</strong> results were found. You are on page <strong>{{ .CurrentPage }}</strong> of <strong> {{ .TotalPages }}</strong>.</p> {{ else if (ne .SearchKey "") and (eq .Results.TotalResults 0) }} <p>No results found for your query: <strong>{{ .SearchKey }}</strong>.</p> {{ end }} </div> 

, , .

Heroku

, , Heroku. , , . . freshman-news .

, Heroku . heroku login , Heroku.

, git- . , git init , , heroku git-. freshman-news .

 heroku git:remote -a freshman-news 

Procfile ( touch Procfile ) :

 web: bin/news-demo -apikey $NEWS_API_KEY 

GitHub Go, , go.mod , . , , .

 module github.com/freshman-tech/news-demo go 1.12.9 

Settings Heroku Reveal Config Vars . NEWS_API_KEY , .

, Heroku :

 git add . git commit -m "Initial commit" git push heroku master 

https://__.herokuapp.com , .

निष्कर्ष

News Go -. , Heroku.

, . - , , .

पढ़ने के लिए धन्यवाद!