शुरुआती के लिए भाषा जाओ

इस लेख का उद्देश्य उन डेवलपर्स के लिए गो (गोलंग) प्रोग्रामिंग भाषा के बारे में बात करना है जो इस भाषा की ओर देखते हैं, लेकिन अभी तक इसका अध्ययन करने का फैसला नहीं किया है। कहानी एक वास्तविक एप्लिकेशन के उदाहरण पर आयोजित की जाएगी, जो एक RESTful API वेब सेवा है।

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

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

गो भाषा के मुख्य लाभ:

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

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

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

परियोजना की संरचना इस प्रकार थी:

/project/ /conf/ errors.go settings.go /controllers/ posts.go users.go /models/ posts.go users.go /utils/ helpers.go loctalk.go 

गो में प्रोग्राम पैकेज में विभाजित है, जो प्रत्येक फ़ाइल की शुरुआत में इंगित किया गया है। पैकेज का नाम उस निर्देशिका के अनुरूप होना चाहिए जिसमें पैकेज में शामिल फाइलें स्थित हैं। मुख्य () फ़ंक्शन के साथ एक मुख्य मुख्य पैकेज भी होना चाहिए। मैं यह loctalk.go आवेदन की जड़ फ़ाइल में है। इस प्रकार, मुझे 5 पैकेज मिले: कॉन्फ, कंट्रोलर, मॉडल, बर्तन, मुख्य।
मैं फ़ाइलों की अपूर्ण सामग्री का हवाला दूंगा, लेकिन समझने के लिए केवल न्यूनतम आवश्यक।

कॉन्फ पैकेज में स्थिरांक और साइट सेटिंग्स हैं।

 package conf import ( "os" ) const ( SITE_NAME string = "LocTalk" DEFAULT_LIMIT int = 10 MAX_LIMIT int = 1000 MAX_POST_CHARS int = 1000 ) func init() { mode := os.Getenv("MARTINI_ENV") switch mode { case "production": SiteUrl = "http://loctalk.net" AbsolutePath = "/path/to/project/" default: SiteUrl = "http://127.0.0.1" AbsolutePath = "/path/to/project/" } } 

मुझे लगता है कि इस पर टिप्पणी करने के लिए कुछ नहीं है। इनिट () फ़ंक्शन को मुख्य कॉल करने से पहले प्रत्येक पैकेज में कहा जाता है ()। विभिन्न फ़ाइलों में कई हो सकते हैं।

मुख्य पैकेज।

 package main import ( "github.com/go-martini/martini" "net/http" "loctalk/conf" "loctalk/controllers" "loctalk/models" "loctalk/utils" ) func main() { m := martini.Classic() m.Use(func(w http.ResponseWriter) { w.Header().Set("Content-Type", "application/json; charset=utf-8") }) m.Map(new(utils.MarshUnmarsh)) Auth := func(mu *utils.MarshUnmarsh, req *http.Request, rw http.ResponseWriter) { reqUserId := req.Header.Get("X-Auth-User") reqToken := req.Header.Get("X-Auth-Token") if !models.CheckToken(reqUserId, reqToken) { rw.WriteHeader(http.StatusUnauthorized) rw.Write(mu.Marshal(conf.ErrUserAccessDenied)) } } // ROUTES m.Get("/", controllers.Home) // users m.Get("/api/v1/users", controllers.GetUsers) m.Get("/api/v1/users/:id", controllers.GetUserById) m.Post("/api/v1/users", controllers.CreateUser) // … // posts m.Get("/api/v1/posts", controllers.GetRootPosts) m.Get("/api/v1/posts/:id", controllers.GetPostById) m.Post("/api/v1/posts", Auth, controllers.CreatePost) // ... m.Run() } 

बहुत ऊपर, पैकेज नाम परिभाषित किया गया है। निम्नलिखित आयातित पैकेजों की एक सूची है। हम मार्टिनी पैकेज का उपयोग करेंगे। यह वेब एप्लिकेशन को जल्दी और आसानी से बनाने के लिए एक हल्की परत जोड़ता है। ध्यान दें कि यह पैकेज कैसे आयात किया जाता है। आपको उस रिपॉजिटरी के लिए पथ निर्दिष्ट करना होगा जहाँ से इसे लिया गया था। और इसे प्राप्त करने के लिए, बस कंसोल में, टाइप करें कमांड जाओ github.com/go-martini/martini

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

हमारे मामले में चर m में टाइप * ClassicMartini है, यह ठीक वैसा ही है जैसे कि martini.Classic () रिटर्न। * का मतलब है एक पॉइंटर, यानी, मान स्वयं संचरित नहीं होता है, बल्कि केवल एक पॉइंटर होता है। M.Use () विधि में, हम एक हैंडलर फ़ंक्शन पास करते हैं। यह मिडलवेयर मार्टिनी को प्रत्येक अनुरोध पर विशिष्ट कार्य करने की अनुमति देता है। इस मामले में, हम प्रत्येक अनुरोध के लिए एक सामग्री-प्रकार को परिभाषित करते हैं। M.Map () विधि आपको हमारी संरचना को बांधने की अनुमति देती है और यदि आवश्यक हो (निर्भरता इंजेक्शन तंत्र) नियंत्रक में इसका उपयोग करें। इस स्थिति में, मैंने डेटा संरचना को json प्रारूप में एन्कोड करने के लिए एक आवरण बनाया।

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

Conf पैकेज की त्रुटियों.go फ़ाइल पर एक नज़र डालें।

 package conf import ( "fmt" "net/http" ) type ApiError struct { Code int `json:"errorCode"` HttpCode int `json:"-"` Message string `json:"errorMsg"` Info string `json:"errorInfo"` } func (e *ApiError) Error() string { return e.Message } func NewApiError(err error) *ApiError { return &ApiError{0, http.StatusInternalServerError, err.Error(), ""} } var ErrUserPassEmpty = &ApiError{110, http.StatusBadRequest, "Password is empty", ""} var ErrUserNotFound = &ApiError{123, http.StatusNotFound, "User not found", ""} var ErrUserIdEmpty = &ApiError{130, http.StatusBadRequest, "Empty User Id", ""} var ErrUserIdWrong = &ApiError{131, http.StatusBadRequest, "Wrong User Id", ""} // …  . . 

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

 type error interface { Error() string } 

इस प्रकार, इस इंटरफ़ेस को लागू करने के लिए, त्रुटि () विधि स्ट्रिंग होना पर्याप्त है। मैंने अपना स्वयं का एरर टाइप ApiError बनाया, जो मेरे कार्यों के लिए अधिक विशिष्ट है, लेकिन अंतर्निहित त्रुटि प्रकार के साथ संगत है।

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

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

हम आगे बढ़ते हैं। Func (e * ApiError) Error () स्ट्रिंग की परिभाषा का अर्थ इस संरचना की एक विधि से अधिक कुछ नहीं है। चर ई एक संरचना के लिए एक संकेतक है, एक प्रकार का स्वयं / यह। तदनुसार, संरचना पर .Error () पद्धति को कॉल करके, हमें इसका संदेश फ़ील्ड मिलता है।

अगला, हम पूर्वनिर्धारित त्रुटियों की पहचान करते हैं और उनके क्षेत्रों में भरते हैं। प्रपत्र के फ़ील्ड http.StatusBadRequest मानक प्रतिक्रिया कोड के लिए http पैकेज में अंतर मान हैं, एक प्रकार का उपनाम। हम आरंभ के साथ & ApiError {} संरचना की घोषणा के लिए शॉर्टहैंड सिंटैक्स का उपयोग करते हैं। दूसरे तरीके से, कोई इसे लिख सकता है:

 MyError := new(ApiError) MyError.Code = 110 // … 

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

चलो हमारे मॉडल पर चलते हैं। यहाँ पोस्ट मॉडल का एक नीचे छीन संस्करण है:

 package models import ( "labix.org/v2/mgo/bson" "loctalk/conf" "loctalk/utils" "time" "unicode/utf8" "log" ) // GeoJSON format type Geo struct { Type string `json:"-"` Coordinates [2]float64 `json:"coordinates"` } type Post struct { Id bson.ObjectId `json:"id" bson:"_id,omitempty"` UserId bson.ObjectId `json:"userId"` UserName string `json:"userName"` ThumbUrl string `json:"thumbUrl"` ParentId bson.ObjectId `json:"parentId,omitempty" bson:",omitempty"` Enabled bool `json:"-"` Body string `json:"body"` Geo Geo `json:"geo"` Date time.Time `json:"date" bson:",omitempty"` } func NewPost() *Post { return new(Post) } func (p *Post) LoadById(id string) *conf.ApiError { if !bson.IsObjectIdHex(id) { return conf.ErrPostIdWrong } session := utils.NewDbSession() defer session.Close() c := session.Col("posts") err := c.Find(bson.M{"_id": bson.ObjectIdHex(id), "enabled": true}).One(p) if p.Id == "" { return conf.ErrPostNotFound } if err != nil { return conf.NewApiError(err) } return nil } func (p *Post) Create() (id string, err *conf.ApiError) { // validation switch { case p.UserId == "": err = conf.ErrUserIdEmpty case p.Body == "": err = conf.ErrPostBodyEmpty case utf8.RuneCountInString(p.Body) > conf.MAX_POST_CHARS: err = conf.ErrPostMaxSize case p.Geo.Coordinates[0] == 0.0 || p.Geo.Coordinates[1] == 0.0: err = conf.ErrPostLocationEmpty } if err != nil { return } p.Id = bson.NewObjectId() p.Geo.Type = "Point" p.Enabled = true p.Date = time.Now() session := utils.NewDbSession() defer session.Close() c := session.Col("posts") errDb := c.Insert(p) if errDb != nil { return "", conf.NewApiError(errDb) } return p.Id.Hex(), nil } func (p *Post) Update() *conf.ApiError { session := utils.NewDbSession() defer session.Close() c := session.Col("posts") err := c.UpdateId(p.Id, p) if err != nil { return conf.NewApiError(err) } return nil } func (p *Post) Disable() *conf.ApiError { session := utils.NewDbSession() defer session.Close() p.Enabled = false c := session.Col("posts") err := c.UpdateId(p.Id, p) if err != nil { return conf.NewApiError(err) } return nil } // … 

यहां हम डेटा बचाने के लिए MongoDb - mgo के लिए अद्भुत ड्राइवर का उपयोग करते हैं। सुविधा के लिए, मैंने mgo api - utils.NewDbSession पर एक छोटा रैपर बनाया। डेटा के साथ काम करने का तर्क: पहले हम भाषा की आंतरिक संरचना में एक वस्तु बनाते हैं, और फिर, इस संरचना की विधि का उपयोग करके, इसे डेटाबेस में सहेजें।

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

खैर, यह नियंत्रक पर एक नज़र रखना है, जो अनुरोधों को संसाधित करता है और प्रतिक्रिया में जोंस प्रदर्शित करता है।

 package controllers import ( "encoding/json" "fmt" "github.com/go-martini/martini" "labix.org/v2/mgo/bson" "loctalk/conf" "loctalk/models" "loctalk/utils" "net/http" ) func GetPostById(mu *utils.MarshUnmarsh, params martini.Params) (int, []byte) { id := params["id"] post := models.NewPost() err := post.LoadById(id) if err != nil { return err.HttpCode, mu.Marshal(err) } return http.StatusOK, mu.Marshal(post) } // ... 

यहां हमें URL से अनुरोधित पोस्ट की आईडी मिलती है, हमारी संरचना का एक नया उदाहरण बनाते हैं और डेटाबेस से डेटा लोड करने और इस संरचना को भरने के लिए उस पर LoadById (आईडी) विधि कहते हैं। जिसे हम अपने mu.Marshal (पोस्ट) विधि का उपयोग करके json में परिवर्तित करने के बाद HTTP पर आउटपुट करते हैं।

फ़ंक्शन के हस्ताक्षर पर ध्यान दें:

 func GetPostById(mu *utils.MarshUnmarsh, params martini.Params) (int, []byte) 

मार्टिनी हमें निर्भरता इंजेक्शन तंत्र का उपयोग करके इनपुट पैरामीटर प्रदान करता है। और हम दो मापदंडों (उदाहरण, [] बाइट) - एक संख्या (प्रतिक्रिया स्थिति) और बाइट्स की एक सरणी लौटाते हैं।

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

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

UPD: रशियन में टूर गो ।