🍁 🤛🏻 👨‍⚕️ हम गो में इंटरफेस के साथ सौदा करते हैं 🏪 ™️ ▶️

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

मानव भाषा में समझाने के लिए कि इंटरफेस क्या हैं।
बताएं कि वे कैसे उपयोगी हैं और आप उन्हें अपने कोड में कैसे उपयोग कर सकते हैं।
किस interface{} बारे में बात interface{} एक खाली इंटरफ़ेस है।
और कुछ उपयोगी इंटरफ़ेस प्रकारों से गुजरें जो आप मानक पुस्तकालय में पा सकते हैं।

तो एक इंटरफ़ेस क्या है?

गो में इंटरफ़ेस प्रकार एक परिभाषा है । यह उन विशिष्ट तरीकों को परिभाषित और वर्णित करता है जो कुछ अन्य प्रकार के होने चाहिए ।

मानक पुस्तकालय से इंटरफ़ेस प्रकारों में से एक fmt.Stringer इंटरफ़ेस है:

 type Stringer interface { String() string }

हम कहते हैं कि कुछ इस इंटरफ़ेस को संतुष्ट करता है (या इस इंटरफ़ेस को लागू करता है ) यदि यह "कुछ" एक विशिष्ट हस्ताक्षर स्ट्रिंग मान String() साथ एक विधि है।

उदाहरण के लिए, Book प्रकार इंटरफ़ेस को संतुष्ट करता है क्योंकि इसमें String() स्ट्रिंग विधि है:

 type Book struct { Title string Author string } func (b Book) String() string { return fmt.Sprintf("Book: %s - %s", b.Title, b.Author) }

इससे कोई फर्क नहीं पड़ता कि Book किस प्रकार की Book या वह क्या करती है। यह सब मायने रखता है कि इसमें String() नामक एक विधि है जो एक स्ट्रिंग मान लौटाता है।

यहाँ एक और उदाहरण है। Count प्रकार भी fmt.Stringer इंटरफ़ेस को संतुष्ट करता है क्योंकि इसमें समान हस्ताक्षर स्ट्रिंग मान String() साथ एक विधि है।

 type Count int func (c Count) String() string { return strconv.Itoa(int(c)) }

यहां यह समझना महत्वपूर्ण है कि हमारे पास दो अलग-अलग प्रकार के Book और Count , जो अलग-अलग कार्य करते हैं। लेकिन वे इस तथ्य से एकजुट हैं कि वे दोनों fmt.Stringer इंटरफ़ेस को संतुष्ट करते हैं।

आप इसे दूसरी तरफ से देख सकते हैं। यदि आप जानते हैं कि ऑब्जेक्ट fmt.Stringer इंटरफ़ेस को संतुष्ट करता है, तो आप मान सकते हैं कि इसमें हस्ताक्षर स्ट्रिंग मूल्य String() साथ एक विधि है जिसे आप कॉल कर सकते हैं।

और अब सबसे महत्वपूर्ण बात।

जब आपको गो (एक चर, फ़ंक्शन पैरामीटर या संरचना क्षेत्र) में एक घोषणा दिखाई देती है, जिसमें एक इंटरफ़ेस प्रकार होता है, तो आप किसी भी प्रकार के ऑब्जेक्ट का उपयोग तब तक कर सकते हैं जब तक कि वह इंटरफ़ेस को संतुष्ट न कर दे।

मान लें कि हमारे पास एक फ़ंक्शन है:

 func WriteLog(s fmt.Stringer) { log.Println(s.String()) }

चूंकि WriteLog() पैरामीटर fmt.Stringer में इंटरफ़ेस प्रकार fmt.Stringer का उपयोग करता है, हम fmt.Stringer इंटरफ़ेस को संतुष्ट करने वाली किसी भी वस्तु को पारित कर सकते हैं। उदाहरण के लिए, हम Book और Count प्रकारों को पास कर सकते हैं जो हमने WriteLog() विधि में पहले बनाए थे, और कोड ठीक काम करेगा।

इसके अलावा, चूंकि पारित वस्तु fmt.Stringer इंटरफ़ेस को संतुष्ट fmt.Stringer है, इसलिए हम जानते हैं कि इसमें एक String() विधि है, जिसे WriteLog() फ़ंक्शन WriteLog() द्वारा सुरक्षित रूप से कॉल किया जा सकता है।

आइए, इंटरफेस की शक्ति का प्रदर्शन करते हुए इसे एक उदाहरण में एक साथ रखें।

 package main import ( "fmt" "strconv" "log" ) //   Book,    fmt.Stringer. type Book struct { Title string Author string } func (b Book) String() string { return fmt.Sprintf("Book: %s - %s", b.Title, b.Author) } //   Count,    fmt.Stringer. type Count int func (c Count) String() string { return strconv.Itoa(int(c)) } //   WriteLog(),    , //   fmt.Stringer   . func WriteLog(s fmt.Stringer) { log.Println(s.String()) } func main() { //   Book    WriteLog(). book := Book{"Alice in Wonderland", "Lewis Carrol"} WriteLog(book) //   Count    WriteLog(). count := Count(3) WriteLog(count) }

यह कमाल है। मुख्य फ़ंक्शन में, हमने विभिन्न प्रकार के Book और Count बनाए, लेकिन उन्हें एक ही WriteLog() फ़ंक्शन में पास किया। और उसने उपयुक्त String() फ़ंक्शन को कॉल किया और लॉग को परिणाम लिखा।

यदि आप कोड निष्पादित करते हैं , तो आपको एक समान परिणाम मिलेगा:

 2009/11/10 23:00:00 Book: Alice in Wonderland - Lewis Carrol 2009/11/10 23:00:00 3

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

उपयोगी इंटरफेस क्या हैं?

कई कारण हैं कि आप गो में इंटरफेस का उपयोग क्यों शुरू कर सकते हैं। और मेरे अनुभव में, सबसे महत्वपूर्ण हैं:

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

आइए इंटरफेस का उपयोग करने के इन तरीकों पर करीब से नज़र डालें।

बॉयलरप्लेट कोड की मात्रा कम करें

मान लीजिए कि हमारे पास एक Customer संरचना है जिसमें कुछ प्रकार के ग्राहक डेटा हैं। कोड के एक भाग में, हम बाइट्स को यह जानकारी लिखना चाहते हैं। बफ़र , और दूसरे भाग में हम डिस्क पर क्लाइंट डेटा को os.File पर लिखना चाहते हैं। लेकिन, दोनों ही मामलों में, हम पहले JSON के ustomer संरचना को क्रमबद्ध करना चाहते हैं।

इस परिदृश्य में, हम गो इंटरफेस का उपयोग करके बॉयलरप्लेट कोड की मात्रा को कम कर सकते हैं।

गो में एक io.Writer इंटरफ़ेस प्रकार है:

 type Writer interface { Write(p []byte) (n int, err error) }

और हम इस तथ्य का लाभ उठा सकते हैं कि बाइट्स। बफ़र और ओएस.फाइल प्रकार इस इंटरफ़ेस को संतुष्ट करते हैं, क्योंकि उनके पास क्रमशः बाइट्स होते हैं। बफ़र.व्रीट () और ओएस.फाइल। वाइट () तरीके, क्रमशः।

सरल कार्यान्वयन:

 package main import ( "encoding/json" "io" "log" "os" ) //   Customer. type Customer struct { Name string Age int } //   WriteJSON,   io.Writer   . //    ustomer  JSON,     // ,     Write()  io.Writer. func (c *Customer) WriteJSON(w io.Writer) error { js, err := json.Marshal(c) if err != nil { return err } _, err = w.Write(js) return err } func main() { //   Customer. c := &Customer{Name: "Alice", Age: 21} //    Buffer    WriteJSON var buf bytes.Buffer err := c.WriteJSON(buf) if err != nil { log.Fatal(err) } //   . f, err := os.Create("/tmp/customer") if err != nil { log.Fatal(err) } defer f.Close() err = c.WriteJSON(f) if err != nil { log.Fatal(err) } }

बेशक, यह सिर्फ एक काल्पनिक उदाहरण है (हम समान परिणाम प्राप्त करने के लिए कोड को अलग तरीके से संरचना कर सकते हैं)। लेकिन यह इंटरफेस का उपयोग करने के फायदों को अच्छी तरह से दिखाता है: हम एक बार Customer.WriteJSON() विधि बना सकते हैं और इसे हर बार कॉल कर सकते हैं जिसे हमें कुछ लिखने की ज़रूरत है जो io.Writer इंटरफ़ेस को संतुष्ट करता है।

लेकिन अगर आप गो के लिए नए हैं, तो आपके पास कुछ सवाल होंगे: “ मुझे कैसे पता चलेगा कि io.Writer इंटरफ़ेस बिल्कुल मौजूद है? और आप पहले से कैसे जानते हैं कि वह bytes.Buffer से संतुष्ट है। bytes.Buffer और os.File ? "

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

लेकिन भले ही आप मानक पुस्तकालय से इंटरफेस का उपयोग नहीं करते हैं, लेकिन कुछ भी आपको अपने स्वयं के इंटरफ़ेस प्रकार बनाने और उपयोग करने से रोकता है। हम इस बारे में नीचे बात करेंगे।

यूनिट टेस्टिंग और स्टब्स

यह समझने के लिए कि इकाई परीक्षण में इंटरफेस कैसे मदद करते हैं, आइए अधिक जटिल उदाहरण देखें।

मान लीजिए कि आपके पास PostgreSQL में बिक्री और ग्राहकों की संख्या के बारे में जानकारी है। आप एक कोड लिखना चाहते हैं जो पिछले दिन के लिए बिक्री के हिस्से की गणना करता है (प्रति ग्राहक बिक्री की विशिष्ट संख्या), दो दशमलव स्थानों के लिए।

एक न्यूनतम कार्यान्वयन इस तरह दिखेगा:

 // : main.go package main import ( "fmt" "log" "time" "database/sql" _ "github.com/lib/pq" ) type ShopDB struct { *sql.DB } func (sdb *ShopDB) CountCustomers(since time.Time) (int, error) { var count int err := sdb.QueryRow("SELECT count(*) FROM customers WHERE timestamp > $1", since).Scan(&count) return count, err } func (sdb *ShopDB) CountSales(since time.Time) (int, error) { var count int err := sdb.QueryRow("SELECT count(*) FROM sales WHERE timestamp > $1", since).Scan(&count) return count, err } func main() { db, err := sql.Open("postgres", "postgres://user:pass@localhost/db") if err != nil { log.Fatal(err) } defer db.Close() shopDB := &ShopDB{db} sr, err := calculateSalesRate(shopDB) if err != nil { log.Fatal(err) } fmt.Printf(sr) } func calculateSalesRate(sdb *ShopDB) (string, error) { since := time.Now().Sub(24 * time.Hour) sales, err := sdb.CountSales(since) if err != nil { return "", err } customers, err := sdb.CountCustomers(since) if err != nil { return "", err } rate := float64(sales) / float64(customers) return fmt.Sprintf("%.2f", rate), nil }

अब हम यह calculateSalesRate() करने के लिए कि गणना सही है, की गणना करने के लिए CalculSalesRate calculateSalesRate() फ़ंक्शन के लिए एक इकाई परीक्षण बनाना चाहते हैं।

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

और इंटरफेस बचाव के लिए आते हैं!

हम अपने स्वयं के इंटरफ़ेस प्रकार का निर्माण करेंगे जो CountSales() और CountCustomers() विधियों का वर्णन करता है, जो कि CountCustomers() calculateSalesRate() फ़ंक्शन पर निर्भर करता है। फिर निर्धारित *ShopDB टाइप के बजाय इस इंटरफ़ेस प्रकार को एक पैरामीटर के रूप में उपयोग करने के लिए हस्ताक्षर calculateSalesRate() को *ShopDB करें।

इस तरह:

 // : main.go package main import ( "fmt" "log" "time" "database/sql" _ "github.com/lib/pq" ) //    ShopModel.     //     ,     //  -,     . type ShopModel interface { CountCustomers(time.Time) (int, error) CountSales(time.Time) (int, error) } //  ShopDB    ShopModel,   //       -- CountCustomers()  CountSales(). type ShopDB struct { *sql.DB } func (sdb *ShopDB) CountCustomers(since time.Time) (int, error) { var count int err := sdb.QueryRow("SELECT count(*) FROM customers WHERE timestamp > $1", since).Scan(&count) return count, err } func (sdb *ShopDB) CountSales(since time.Time) (int, error) { var count int err := sdb.QueryRow("SELECT count(*) FROM sales WHERE timestamp > $1", since).Scan(&count) return count, err } func main() { db, err := sql.Open("postgres", "postgres://user:pass@localhost/db") if err != nil { log.Fatal(err) } defer db.Close() shopDB := &ShopDB{db} sr := calculateSalesRate(shopDB) fmt.Printf(sr) } //       ShopModel    //    *ShopDB. func calculateSalesRate(sm ShopModel) string { since := time.Now().Sub(24 * time.Hour) sales, err := sm.CountSales(since) if err != nil { return "", err } customers, err := sm.CountCustomers(since) if err != nil { return "", err } rate := float64(sales) / float64(customers) return fmt.Sprintf("%.2f", rate), nil }

ऐसा करने के बाद, हम सिर्फ एक स्टब ShopModel जो ShopModel इंटरफ़ेस को संतुष्ट करता है। फिर आप फ़ंक्शन calculateSalesRate() में गणितीय तर्क के सही संचालन के यूनिट परीक्षण के दौरान इसका उपयोग कर सकते calculateSalesRate() । इस तरह:

 // : main_test.go package main import ( "testing" ) type MockShopDB struct{} func (m *MockShopDB) CountCustomers() (int, error) { return 1000, nil } func (m *MockShopDB) CountSales() (int, error) { return 333, nil } func TestCalculateSalesRate(t *testing.T) { //  . m := &MockShopDB{} //     calculateSalesRate(). sr := calculateSalesRate(m) // ,        //   . exp := "0.33" if sr != exp { t.Fatalf("got %v; expected %v", sr, exp) } }

अब परीक्षण चलाएं और सब कुछ ठीक चले।

अनुप्रयोग वास्तुकला

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

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

मैंने पिछले पोस्ट में से एक में इस पैटर्न के बारे में लिखा था, अधिक विवरण और व्यावहारिक उदाहरण हैं।

एक खाली इंटरफ़ेस क्या है?

यदि आप कुछ समय के लिए गो पर प्रोग्रामिंग कर रहे हैं, तो आप शायद एक खाली इंटरफ़ेस प्रकार interface{} आ गए हैं। मैं यह समझाने की कोशिश करूंगा कि यह क्या है। इस लेख की शुरुआत में, मैंने लिखा:

गो में इंटरफ़ेस प्रकार एक परिभाषा है । यह उन विशिष्ट तरीकों को परिभाषित और वर्णित करता है जो कुछ अन्य प्रकार के होने चाहिए ।

एक खाली इंटरफ़ेस प्रकार विधियों का वर्णन नहीं करता है । उसके पास कोई नियम नहीं है। और इसलिए कोई भी वस्तु एक खाली इंटरफ़ेस को संतुष्ट करती है।

संक्षेप में, खाली इंटरफ़ेस प्रकार interface{} एक प्रकार का जोकर है। यदि आप इसे एक घोषणा (चर, फ़ंक्शन पैरामीटर या संरचना क्षेत्र) में मिले थे, तो आप किसी भी प्रकार की वस्तु का उपयोग कर सकते हैं।

कोड पर विचार करें:

 package main import "fmt" func main() { person := make(map[string]interface{}, 0) person["name"] = "Alice" person["age"] = 21 person["height"] = 167.64 fmt.Printf("%+v", person) }

यहाँ हम मानचित्र को person लिए आरम्भ करते हैं, जो मानों के लिए स्ट्रिंग प्रकार और रिक्त अंतरफलक प्रकार interface{} लिए interface{} का उपयोग करता है। हमने तीन अलग-अलग प्रकार के नक्शे मान (स्ट्रिंग, पूर्णांक और फ्लोट 32), और कोई समस्या नहीं सौंपी। चूंकि किसी भी प्रकार की वस्तुएं खाली इंटरफ़ेस को संतुष्ट करती हैं, इसलिए कोड बहुत अच्छा काम करता है।

आप इस कोड को यहां चला सकते हैं , आपको एक समान परिणाम दिखाई देगा:

 map[age:21 height:167.64 name:Alice]

जब नक्शे से मान निकालने और उपयोग करने की बात आती है, तो इसे ध्यान में रखना महत्वपूर्ण है। मान लें कि आप age मान प्राप्त करना चाहते हैं और इसे 1 से बढ़ाते हैं। यदि आप एक समान कोड लिखते हैं, तो यह संकलन नहीं करेगा:

 package main import "log" func main() { person := make(map[string]interface{}, 0) person["name"] = "Alice" person["age"] = 21 person["height"] = 167.64 person["age"] = person["age"] + 1 fmt.Printf("%+v", person) }

आपको एक त्रुटि संदेश प्राप्त होगा:

 invalid operation: person["age"] + 1 (mismatched types interface {} and int)

कारण यह है कि मानचित्र में संग्रहीत मूल्य interface{} प्रकार लेता है और अपने मूल, आधार interface{} प्रकार को खो देता है। और चूंकि मान अब पूर्णांक नहीं है, इसलिए हम इसमें 1 नहीं जोड़ सकते।

इसके आस-पास जाने के लिए, आपको फिर से मूल्य पूर्णांक बनाने की आवश्यकता है, और उसके बाद ही इसका उपयोग करें:

 package main import "log" func main() { person := make(map[string]interface{}, 0) person["name"] = "Alice" person["age"] = 21 person["height"] = 167.64 age, ok := person["age"].(int) if !ok { log.Fatal("could not assert value to int") return } person["age"] = age + 1 log.Printf("%+v", person) }

यदि आप इसे चलाते हैं , तो सब कुछ उम्मीद के मुताबिक काम करेगा:

 2009/11/10 23:00:00 map[age:22 height:167.64 name:Alice]

तो आपको खाली इंटरफ़ेस प्रकार का उपयोग कब करना चाहिए?

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

 type Person struct { Name string Age int Height float32 }

दूसरी ओर एक खाली इंटरफ़ेस उपयोगी है, जब आपको अप्रत्याशित या उपयोगकर्ता-परिभाषित प्रकारों के साथ उपयोग करने और काम करने की आवश्यकता होती है। किसी कारण के लिए, इस तरह के इंटरफेस का उपयोग मानक पुस्तकालय में विभिन्न स्थानों में किया जाता है, उदाहरण के लिए, gob.Encode , fmt.Print, और template.Execute फ़ंक्शन में।

उपयोगी इंटरफ़ेस प्रकार

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

मानक पुस्तकालयों की एक लंबी सूची भी यहाँ उपलब्ध है ।

हम गो में इंटरफेस के साथ सौदा करते हैं