गोलांग में स्ट्रक्चर

Question

मैं अभी गोलांग से शुरू कर रहा हूं, और मैं उनके ट्यूटोरियल (https://golang.org/doc/code.html) में से एक को देख रहा हूं।

उनके उदाहरणों में से, उन्होंने एक चर को एक संरचना में सेट किया है, लेकिन मैं इतनी उलझन में हूं कि वे नीचे लूप के लिए संरचना के तत्वों तक कैसे पहुंच रहे हैं? किसी को भी कोई स्पष्टीकरण दे सकता है? आपका बहुत बहुत धन्यवाद!

कोड:

package stringutil 

import "testing" 

func TestReverse(t *testing.T) { 
    cases := []struct { 
     in, want string 
    }{ 
     {"Hello, world", "dlrow ,olleH"}, 
     {"Hello, 世界", "界世 ,olleH"}, 
     {"", ""}, 
    } 
    for _, c := range cases { 
     got := Reverse(c.in) 
     if got != c.want { 
      t.Errorf("Reverse(%q) == %q, want %q", c.in, got, c.want) 
     } 
    } 
} 

Answer 1

नीचे कुछ टिप्पणी के साथ कोड मदद करने के लिए इस में एक बयान भूमिका स्पष्ट है।

import "testing" 

func TestReverse(t *testing.T) { 
    cases := []struct { // declaration of anonymous type 
     in, want string // fields on that type called in and want, both strings 
    }{ 
     {"Hello, world", "dlrow ,olleH"}, 
     {"Hello, 世界", "界世 ,olleH"}, 
     {"", ""}, 
    } // composite literal initilization 
    // note the use of := in assigning to cases, that op combines declaration and assignment into one statement 
    for _, c := range cases { // range over cases, ignoring the index - the underscore means to discard that return value 
     got := Reverse(c.in) // c is the current instance, access in with the familiar dot notation 
     if got != c.want { // again, access operator on c, the current instance 
      t.Errorf("Reverse(%q) == %q, want %q", c.in, got, c.want) // more access 
     } 
    } 
} 

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

संपादित करें: cases

cases := []struct { 
     in, want string 
    } 

घुंघराले ब्रेसिज़ के पहली जोड़ी के अंदर इस बिट की घोषणा/initilization पर विवरण एक struct की परिभाषा है। यह एक अनाम प्रकार है, एक सामान्य घोषणा इस तरह दिखेगी; (निर्यात नहीं किया, यदि आप बनाने के लिए यह सार्वजनिक 'यह बजाय type Case की आवश्यकता होगी तो चाहता था)

type case strcut { 
     in string 
     want string 
    } 

आप कुछ इस तरह था, तो फिर वहाँ एक प्रकार इस पैकेज के दायरे में case कहा जाता होगा। इसके बजाय उदाहरण संरचना अज्ञात है। यह सामान्य प्रकार के समान काम करता है, हालांकि डेवलपर के रूप में, आपके पास उस प्रकार का संदर्भ देने का कोई तरीका नहीं होगा ताकि आप केवल प्रारंभिक संग्रह के साथ व्यावहारिक रूप से काम कर सकें। आंतरिक रूप से यह प्रकार फ़ील्ड के लिए 2 अप्रत्याशित तारों के साथ किसी भी अन्य संरचना के समान है। फ़ील्ड का नाम in और want रखा गया है। ध्यान दें कि असाइनमेंट में cases := []struct आपके पास []struct से पहले इसका मतलब है कि आप इस अनाम प्रकार का एक टुकड़ा घोषित कर रहे हैं।

यह अगला छोटा सा, स्थिर इनिटिलाइजेशन कहा जाता है। संग्रहों को प्रारंभ करने के लिए यह एक वाक्यविन्यास है। {"", ""} जैसे इन नेस्टेड बिट्स में से प्रत्येक इन अज्ञात structs में से एक की घोषणा और initilization है, घुंघराले ब्रेसिज़ द्वारा फिर से दर्शाया गया है। इस मामले में आप क्रमश: in और want पर दो खाली तारों को असाइन कर रहे हैं (यदि आप नामों का उपयोग नहीं करते हैं, तो ऑर्डर परिभाषा के समान है)। ब्रेसिज़ की बाहरी जोड़ी स्लाइस के लिए है। यदि आपका टुकड़ा चींटियों या तारों के बारे में कहता था, तो आपके पास myInts := []int{5,6,7} जैसे घोंसले के अतिरिक्त स्तर के बिना केवल वही मूल्य होंगे।

{ 
     {"Hello, world", "dlrow ,olleH"}, 
     {"Hello, 世界", "界世 ,olleH"}, 
     {"", ""}, 
    } 

Answer 2

संरचना क्या है इसकी जड़ जाओ।

आप इसमें अपने चर घोषित करते हैं तो आप इसे किसी फ़ंक्शन से उपयोग कर सकते हैं। उदाहरण:

package main 

import (
    "fmt" 

) 

func main() { 
    Get() 

} 

func Get(){ 
    out := new(Var) 

    out.name = "james" 

    fmt.Println(out.name) 
} 
type Var struct { 
    name string 
} 

Answer 3

आप Golang Struc

 
// GO language program with an example of Struc Type 

package main 

import (
"fmt" 
) 

func main() { 
    type Salary struct{ 
     Basic, HRA, TA float64  
    } 

    type Employee struct{ 
     FirstName, LastName, Email string 
     Age int 
     MonthlySalary []Salary 
    } 

    e := Employee{ 
     FirstName: "Mark", 
     LastName: "Jones", 
     Email: "mark@gmail.com", 
     Age: 25, 
     MonthlySalary: []Salary{ 
      Salary{ 
       Basic:15000.00, 
       HRA:5000.00, 
       TA:2000.00, 
      }, 
      Salary{ 
       Basic:16000.00, 
       HRA:5000.00, 
       TA:2100.00, 
      }, 
      Salary{ 
       Basic:17000.00, 
       HRA:5000.00, 
       TA:2200.00, 
      }, 
     }, 
    } 
    fmt.Println(e.FirstName,e.LastName) 
    fmt.Println(e.Age) 
    fmt.Println(e.Email) 
    fmt.Println(e.MonthlySalary[0]) 
    fmt.Println(e.MonthlySalary[1]) 
    fmt.Println(e.MonthlySalary[2]) 
}