गो के साथ परिचित - हम मल्टीथ्रेडिंग और हार्लोट्स के साथ वेब पेजों का एक धरनेवाला लिखते हैं

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

इंटरनेट पर एक साइट है http://vpustotu.ru जहां कोई भी दर्दनाक रूप से गुमनाम रूप से बोल सकता है। सभी कथन (भविष्य में मैं उन्हें "उद्धरण" कहूंगा) सबसे पहले मॉडरेशन (बैशॉर्ज के "रसातल का एक एनालॉग) में आते हैं, जहां आगंतुक विचार की उड़ान का मूल्यांकन कर सकते हैं और" वाह! "या" बुलशिट! "की शैली में उद्धरण के लिए वोट कर सकते हैं। मॉडरेशन पेज ( http://vpustotu.ru/moderation/ ) पर हमें एक यादृच्छिक उद्धरण, मतदान लिंक और एक "अधिक" लिंक दिखाया जाता है जो एक ही पृष्ठ पर ले जाता है। क्लिक करें, यह सब बहुत सरल है।

और इसलिए कार्य उत्पन्न हुआ - तुरंत, अंधेरे के आवरण के नीचे, आगे के गुप्त शोध के लिए मॉडरेशन पर सभी उद्धरणों का एक पूरा डंप खुद को अपलोड करने के लिए। हम सांसारिक मूल्य और कार्य की मूर्खता की डिग्री का मूल्यांकन नहीं करेंगे, लेकिन तकनीकी दृष्टिकोण से इस पर विचार करेंगे:

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

इस प्रकार, आपको एक कार्यक्रम की आवश्यकता है:

• पृष्ठ को लगातार अद्यतन और पार्स (पार्स) करना चाहिए, एक उद्धरण लिखकर।
• डुप्लिकेट को छोड़ने में सक्षम होना चाहिए।

यह तर्कसंगत है कि हमारे पास कोई विचार नहीं है कि सभी उद्धरण लोड किए गए हैं, लेकिन एक पंक्ति में बड़ी संख्या में बार-बार प्राप्त उद्धरणों से यह अप्रत्यक्ष रूप से अनुमान लगाया जा सकता है। इसलिए, हम पूरक हैं:

• न केवल आदेश पर रोकना चाहिए, बल्कि "पुनरावृत्ति" की एक निश्चित संख्या तक पहुंचने पर, उदाहरण के लिए 500!
• चूंकि इसमें कुछ समय लगने की संभावना है: बंद होने के बाद आपको "जहाँ से आपने छोड़ा था" जारी रखने में सक्षम होना चाहिए।
• खैर, चूंकि अभी भी एक लंबा समय है - इसे कई धाराओं में अपना गंदा काम करने दें। ठीक है, यह 4 थ्रेड्स (या 5) के रूप में कई में होगा।
• और हर सेकंड, कहते हैं, 10 सेकंड के लिए सफलताओं पर रिपोर्ट।
• और उन्हें कमांड लाइन के तर्कों से इन सभी मापदंडों को स्वीकार करने दें!

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

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

package main import ( "fmt" ) func main() { fmt.Println("Hello World!") } 

हम सूची के माध्यम से और कार्यक्रम के क्रम में जाना शुरू करते हैं:

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

 import ( "flag" "fmt" ) var ( WORKERS int = 2 //- "" REPORT_PERIOD int = 10 //  () DUP_TO_STOP int = 500 //    HASH_FILE string = "hash.bin" //   QUOTES_FILE string = "quotes.txt" //   ) 

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

आम तौर पर init () फ़ंक्शन में पार्सिंग तर्क जैसी चीजें की जाती हैं, और हम करेंगे:

 func init() { //  : flag.IntVar(&WORKERS, "w", WORKERS, " ") flag.IntVar(&REPORT_PERIOD, "r", REPORT_PERIOD, "  ()") flag.IntVar(&DUP_TO_STOP, "d", DUP_TO_STOP, "-   ") flag.StringVar(&HASH_FILE, "hf", HASH_FILE, " ") flag.StringVar(&QUOTES_FILE, "qf", QUOTES_FILE, " ") //    flag.Parse() } 

UPD: एक टिप्पणी में फोर्क्ड हैबराइज़र ने लोकप्रिय रूप से समझाया कि ध्वज को क्यों बुलाना है। Inar () फ़ंक्शन init एक बुरी आदत है। इसके लिए उन्हें धन्यवाद - अब से मैं इसे मुख्य () में करूंगा, जो मैं आपको सलाह देता हूं, लेकिन यह उदाहरण एक संपादन के रूप में यहां रहेगा कि "फू ऐसा करें!"

हम फ़्लैग पैकेज से फ़ंक्शंस (संख्याओं के लिए) और स्ट्रिंग के लिए स्ट्रिंगर ( फ़ंक्शंस के लिए) का उपयोग करते हैं - वे कमांड लाइन के तर्कों से निर्दिष्ट कुंजी को पढ़ते हैं और इसे वेरिएबल में पास करते हैं। यदि कुंजी निर्दिष्ट नहीं है, तो डिफ़ॉल्ट मान लिया जाता है। फ़ंक्शन के लिए सिंटैक्स समान है:

 flag.StringVar( &_,  . ,    ,  ) 

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

 C:\Go\src\habratest>habratest.exe -h Usage of habratest.exe: -d=500: -    -hf="hash.bin":   -qf="quotes.txt":   -r=10:   () -w=2:   

आगे की योजना के अनुसार, कार्यक्रम शुरू होने पर हैश लोड किया जाता है, लेकिन मेरा सुझाव है कि इस पर बाद में लौटें, जब हमारे पास पहले से ही कुछ लोड करना है। कल्पना कीजिए कि अब के लिए, हर लॉन्च पहले है।

अब चलो प्रोग्राम के बारे में ही सोचते हैं - इसे पृष्ठ को पढ़ना चाहिए, इसे अलग करना चाहिए, परिणामों को रिकॉर्ड करना चाहिए और प्रगति का विश्लेषण करना चाहिए। हां, और कई "थ्रेड्स" में (तुरंत निर्धारित करें - एक धागा जिसे मैं थ्रेड कहता हूं और स्ट्रीम नहीं। ठीक है, बस मामले में)। हा!

गो में मल्टीटास्किंग को गोरोइटिन द्वारा कार्यान्वित किया जाता है, अर्थात हम किसी भी फ़ंक्शन को "पृष्ठभूमि में" उसके सामने "गो" कीवर्ड को प्रतिस्थापित करके चला सकते हैं: यह शुरू होता है और कार्यक्रम तुरंत जारी रहता है, यह लिनक्स में अंत में & के साथ कमांड चलाने जैसा है - हम तुरंत हम कुछ और कर सकते हैं:

 //   ... func GadgetUmbrella() { //...   ... } //...       ,   : go GadgetUmbrella() fmt.Println(" !") //          ,      GadgetUmbrella() 

सामान्य तौर पर, गोरूटिन शुद्ध धाराएं नहीं हैं, वहां सब कुछ बहुत दिलचस्प है, लेकिन ऐसी चीजें स्पष्ट रूप से हमारे काम के दायरे से परे हैं।

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

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

 func send( c chan int) {  <- 15 //     } func main() { ch := make(chan int) //      (int) go send(ch) b:= <-ch //    fmt.Println(b) } 

कृपया ध्यान दें कि मैंने लिखा है गो (ch) और न सिर्फ भेजें (श) । तथ्य यह है कि, डिफ़ॉल्ट रूप से, एक चैनल से डेटा का प्रसारण और रिसेप्शन सबरूटीन को अवरुद्ध करता है जो उन्हें तब तक रोकते हैं जब तक कि दूसरा छोर डेटा को संसाधित करने के लिए तैयार न हो। यह इतना बड़ा सिंक्रोनाइज़ेशन टूल है।
यह पता चला है कि यदि आप " जाना " हटाते हैं तो भेज दें () मुख्य थ्रेड में निष्पादित हो जाएगा और इसे ब्लॉक कर देगा, क्योंकि यह तब तक इंतजार करेगा जब तक कि कोई हमारे नंबर को लेने के लिए तैयार न हो। 15. हम इसे अगली पंक्ति में उठाएंगे, लेकिन यह कभी नहीं होगा स्थानांतरित नियंत्रण। गतिरोध, हर कोई दुखी है।
लेकिन " गो सेंड () " के मामले में सब कुछ सुचारू रूप से चलेगा, क्योंकि भेजना () अवरुद्ध हो जाएगा , लेकिन इसकी धारा में, और तब तक खड़ा रहेगा जब तक हम दूसरे में नहीं पढ़ते - और हम यह बहुत जल्द करेंगे और डेटा एक्सचेंज होगा सफलतापूर्वक।
इसके अलावा, यदि आप चैनल को भेजें () फ़ंक्शन में लिखते हैं, तो लाइन b पर मुख्य कार्य : = <-c मृत हो जाएगा, इसके विपरीत, क्योंकि इसके पास प्राप्त करने के लिए कुछ भी नहीं होगा।
चैनल क्रमशः प्रथम श्रेणी के ऑब्जेक्ट हैं, उन्हें बनाया जा सकता है, स्थानांतरित किया जा सकता है, लौटाया जा सकता है और सौंपा जा सकता है क्योंकि यह सुविधाजनक होगा।

हम डेटा "ग्रैबर" भेजेंगे और हम उन्हें मुख्य चक्र में प्राप्त करेंगे।

पृष्ठ कोड में बोली बस वर्ग "fi_text" के साथ एक div में निहित है। इसे "धरनेवाला" में प्राप्त करने के लिए हम बकरी के पैकेज का उपयोग करेंगे - यह आपको html पृष्ठ को पार्स करने और चयनकर्ताओं को ला जेएक्यू का उपयोग करने की अनुमति देता है। यह पैकेज मानक पैकेज में नहीं है, इसलिए आपको इसे पहले स्थापित करने की आवश्यकता है:

 #  : go get github.com/opesun/goquery 

और कोड में आयात अनुभाग में हम "github.com/opesun/goquery", "स्ट्रिंग्स" और "समय" पैकेज जोड़ते हैं - हमें देरी के लिए बाद की आवश्यकता है, हम अपने अनुरोधों के साथ सर्वर को लगातार खींचते हैं (अच्छी तरह से, और इसलिए हम करेंगे, लेकिन आप मुझे समझते हैं):

 import ( "flag" "fmt" "github.com/opesun/goquery" "strings" "time" ) 

इस बिंदु के करीब, हम "ग्रैबर" कोड लिखते हैं:

 func grab() <-chan string { //  ,        string c := make(chan string) for i := 0; i < WORKERS; i++ { //       - worker'o go func() { for { //     x, err := goquery.ParseUrl("http://vpustotu.ru/moderation/") if err == nil { if s := strings.TrimSpace(x.Find(".fi_text").Text()); s != "" { c <- s //     } } time.Sleep(100 * time.Millisecond) } }() } fmt.Println(" : ", WORKERS) return c } 

कोड बहुत सरल है और लगभग कोई टिप्पणी नहीं की आवश्यकता है।
हम क्लोजर का उपयोग करते हैं, जिससे हमें जरूरत है कि हम एक गुमनाम फंक्शन करें, जो लगातार पकड़कर लौटे चैनल को डेटा भेजता हो () । इस तरह के पैटर्न को जनरेटर कहा जाता है।
किसी कारण से, x.Find ("। Fi_text")। पाठ () ने शुरुआत में और अंत में रिक्त स्थान के साथ वांछित तत्व की सामग्री मुझे लौटा दी, इसलिए बिना किसी हिचकिचाहट के, हमने इसे मानक स्ट्रैप मॉड्यूल से ट्राइस्पेस स्पेस के साथ साफ़ कर दिया।

तो जनरेटर तैयार है, आप यह सुनिश्चित कर सकते हैं कि यह मुख्य () फ़ंक्शन को संशोधित करके काम करता है:

 func main() { quote_chan := grab() for i := 0; i < 5; i++ { // 5    fmt.Println(<-quote_chan, "\n") } } 

हम शुरू करते हैं और देखते हैं कि सब कुछ योजना के अनुसार हो रहा है: खुलासे हमारे चैनल में एक व्यापक प्रवाह में डालते हैं!


अब चलो मुख्य चक्र के बारे में सोचते हैं, जिसमें, योजना के अनुसार, मूल्यों को एकत्र किया जाना चाहिए। आवश्यकताओं और इच्छाओं के अनुसार, हमें एक चक्र की आवश्यकता है:

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

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

समय रिपोर्ट को मानक " समय " पैकेज से टिकर का उपयोग करके लागू किया जा सकता है। यह सबसे सरल टाइमर है जो एक निश्चित अवधि के बाद चालू हो जाएगा और आपके चैनल को एक निश्चित मूल्य भेजेगा - आपको बस चैनल की निगरानी करने और डेटा आने पर आंकड़े प्रदर्शित करने की आवश्यकता है।

और हम " ओएस / सिग्नल " पैकेज का उपयोग करके पूरा करने के लिए कमांड को पकड़ लेंगे, जो आपको कुछ संकेतों पर एक नोटिफ़ायर को लटका देने की अनुमति देता है जो चैनल को घटना की सूचनाएं भेजता है।

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

कोड के लिए नीचे उतरो! पहले, आयात अनुभाग में आवश्यक पैकेज जोड़ें, अब यह इस तरह दिखेगा:

 import ( "flag" "fmt" "github.com/opesun/goquery" "strings" "time" //,        : "io" "os" "os/signal" //   -   : "crypto/md5" "encoding/hex" ) 

हां, बहुत सारी चीजें ... गो के स्टेटिक लिंकिंग को देखते हुए, निष्पादन योग्य का आकार प्रभावशाली होना चाहिए!
लेकिन यह दुखी होने का समय नहीं है, हम हैश के लिए भंडारण की घोषणा करेंगे:

 var ( ... used map[string]bool = make(map[string]bool) //map        ,    -  . ) 

और अंत में, हमारे मुख्य कार्य में बदल जाता है:

 func main() { //   ... quotes_file, err := os.OpenFile(QUOTES_FILE, os.O_APPEND|os.O_CREATE, 0666) check(err) defer quotes_file.Close() //...    hash_file, err := os.OpenFile(HASH_FILE, os.O_APPEND|os.O_CREATE, 0666) check(err) defer hash_file.Close() // Ticker          ticker := time.NewTicker(time.Duration(REPORT_PERIOD) * time.Second) defer ticker.Stop() // ,     ,     ... key_chan := make(chan os.Signal, 1) signal.Notify(key_chan, os.Interrupt) //...       hasher := md5.New() //    quotes_count, dup_count := 0, 0 // , ! quotes_chan := grab() for { select { case quote := <-quotes_chan: // ""  : quotes_count++ // ,     : hasher.Reset() io.WriteString(hasher, quote) hash := hasher.Sum(nil) hash_string := hex.EncodeToString(hash) //    if !used[hash_string] { //   -    ,        used[hash_string] = true hash_file.Write(hash) quotes_file.WriteString(quote + "\n\n\n") dup_count = 0 } else { //  -   ,    ? if dup_count++; dup_count == DUP_TO_STOP { fmt.Println("  ,  .  : ", len(used)) return } } case <-key_chan: //     : fmt.Println("CTRL-C:  .  : ", len(used)) return case <-ticker.C: //, ,        fmt.Printf(" %d /  %d (%d /) \n", len(used), dup_count, quotes_count/REPORT_PERIOD) quotes_count = 0 } } } 

कोड बिल्कुल पारदर्शी है, हम केवल फाइल खोलने पर ध्यान देंगे:
चेक () फ़ंक्शन मानक नहीं है - यह त्रुटियों के लिए एक फ़ाइल खोलने के परिणामों की जांच की सुविधा के लिए यहां है। यहाँ इसका कोड है, मुख्य के सामने कहीं रखा गया है () :

 func check(e error) { if e != nil { panic(e) } } 

एक और दिलचस्प बिंदु: हम "तुरंत" कारण फ़ाइल को बंद कर देते हैं, हालांकि तब हम इसके साथ काम करने जा रहे हैं:

 defer quotes_file.Close() ... defer hash_file.Close() ... //      : defer ticker.Stop() 

लब्बोलुआब यह है कि फ़ंक्शन को defer के साथ शुरू करने से हम इसके निष्पादन को स्थगित कर देते हैं: इसे केवल उस फ़ंक्शन से पहले निष्पादित किया जाएगा जहां से defer कॉल पूरा हुआ था (दूसरे शब्दों में, "पैरेंट" की वापसी से ठीक पहले)।

आप पहले से ही "बहुत आवश्यक मिशन" की पूर्ति शुरू कर सकते हैं और आनंद ले सकते हैं, लेकिन एक और छोटा विवरण है - आपको फ़ाइल से हैश पढ़ने के लिए एक फ़ंक्शन लिखना होगा, अगर हम प्रोग्राम को फिर से चलाना चाहते हैं, लेकिन परिणामी फ़ाइल में डुप्लिकेट नहीं देखना चाहते हैं। यहाँ ऐसा करने का एक तरीका है:

 func readHashes() { //    if _, err := os.Stat(HASH_FILE); err != nil { if os.IsNotExist(err) { fmt.Println("   ,   .") return } } fmt.Println(" ...") hash_file, err := os.OpenFile(HASH_FILE, os.O_RDONLY, 0666) check(err) defer hash_file.Close() //    16  -    : data := make([]byte, 16) for { n, err := hash_file.Read(data) //n    ,  err - ,   . if err != nil { if err == io.EOF { break } panic(err) } if n == 16 { used[hex.EncodeToString(data)] = true } } fmt.Println(".  : ", len(used)) } 

यह सब, यह केवल रीडहैश () कॉल को मुख्य स्थान की शुरुआत में रखना याद रखना है।

 func main() { readHashes() ... 

हो गया! लड़ाई शुरू:


काम के परिणाम:


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

Pastbin.com पर पूरा कार्यक्रम कोड

यदि आप गो और इसकी विशेषताओं में रुचि रखते हैं, तो यहां कुछ स्थान हैं:

tour.golang.org - भाषा का एक ऑनलाइन दौरा, कोड को सीधे ब्राउज़र में संपादित करना बहुत ही रोमांचक है।

gobyexample.com - सामान्य कार्यों के उदाहरण

golang.org/ref/spec - भाषा विशिष्टता

golang.org/doc/effective_go.html - विषय पर एक लेख "और अब हम यह सब कचरा उठाने की कोशिश करेंगे" - कैसे सही तरीके से उड़ान भरने और उड़ान भरने के लिए

Google Go समूह - " https://groups.google.com/forum/#-forum/golang-nuts " और " https://groups.google.com/forum/#-forum/golang-ru "

Godoc.org - गो पैकेज और उनके प्रलेखन की खोज, बिल्ट-इन और थर्ड-पार्टी, दोनों एक बेहतरीन एंटी-बाइक चीज़ है!

सौभाग्य है