Google गोलैंग डेटा स्ट्रक्चर्स – Google Go (Golang) Data Structures

इस अध्याय में हम Google Go (Golang) में डेटा स्ट्रक्चर्स का अध्ययन करेंगे। डेटा स्ट्रक्चर्स प्रोग्रामिंग में डेटा को संगठित और संरचित करने के लिए आवश्यक होते हैं। गोलैंग में एरेज़, स्लाइस, मैप्स, और स्ट्रक्चर जैसे कई महत्वपूर्ण डेटा स्ट्रक्चर्स होते हैं, जिनका उपयोग करके आप अपने डेटा को अधिक प्रभावी ढंग से मैनेज और प्रोसेस कर सकते हैं। इस अध्याय में आप इन डेटा स्ट्रक्चर्स के साथ काम करने के विभिन्न तरीकों को समझेंगे और अपने प्रोग्राम्स को अधिक कुशल और संगठित बना सकेंगे।

एरेज़ और स्लाइस (Arrays and Slices)

गोलैंग में डेटा को संगठित और संग्रहित करने के लिए एरेज़ (Arrays) और स्लाइस (Slices) का उपयोग किया जाता है। ये डेटा स्ट्रक्चर्स आपको एक ही प्रकार के कई आइटम्स को एक साथ स्टोर करने की अनुमति देते हैं, जिससे आपके कोड में डेटा का प्रबंधन और प्रोसेसिंग अधिक कुशल और सरल हो जाती है।

1. एरेज़ का परिचय (Introduction to Arrays):

एरे (Array) एक निश्चित आकार का डेटा स्ट्रक्चर है जो एक ही प्रकार के आइटम्स को एक साथ स्टोर करता है। एक बार जब एरे का आकार निर्धारित हो जाता है, तो इसे बदला नहीं जा सकता।

var numbers [5]int

इस उदाहरण में, numbers नाम का एक एरे डिक्लेयर किया गया है जो 5 इंटिजर वैल्यूज़ को स्टोर कर सकता है।

आप एरे को डिक्लेयर करते समय इसे वैल्यूज के साथ भी इनिशियलाइज़ कर सकते हैं:

var numbers = [5]int{10, 20, 30, 40, 50}

इस एरे में 5 इंटिजर वैल्यूज़ हैं: 10, 20, 30, 40, और 50।

2. एरे के साथ काम करना (Working with Arrays):

आप एरे में मौजूद आइटम्स तक उनकी पोजीशन (इंडेक्स) के माध्यम से पहुँच सकते हैं। गोलैंग में एरेज़ का इंडेक्स 0 से शुरू होता है।

numbers[0] = 15  // Set the first element to 15
fmt.Println(numbers[0])  // Access the first element

इस उदाहरण में, numbers एरे के पहले आइटम को 15 से सेट किया गया है और फिर उसे प्रिंट किया गया है।

3. स्लाइस का परिचय (Introduction to Slices):

स्लाइस (Slice) गोलैंग में एरे का एक अधिक लचीला और शक्तिशाली वर्शन है। स्लाइस का आकार डायनामिक होता है, यानी आप रनटाइम के दौरान इसे बढ़ा या घटा सकते हैं। स्लाइस वास्तव में एक रेफरेंस होता है जो एक एरे के हिस्से को पॉइंट करता है।

var numbers = []int{10, 20, 30, 40, 50}

इस उदाहरण में, numbers एक स्लाइस है जो 5 इंटिजर वैल्यूज़ को स्टोर करता है।

4. स्लाइस क्रिएशन और ऑपरेशंस (Creating and Manipulating Slices):

स्लाइस बनाने के कई तरीके होते हैं। आप एक नए स्लाइस को एक मौजूदा एरे या स्लाइस से भी बना सकते हैं।

var newSlice = numbers[1:4]  // Create a slice from index 1 to 3

इस उदाहरण में, newSlice नामक स्लाइस numbers स्लाइस के दूसरे (इंडेक्स 1) से चौथे (इंडेक्स 3) आइटम तक के हिस्से को पॉइंट करता है।

आप स्लाइस को append फ़ंक्शन का उपयोग करके भी बढ़ा सकते हैं:

var numbers = []int{10, 20, 30}
numbers = append(numbers, 40, 50)  // Add more elements to the slice

इस उदाहरण में, numbers स्लाइस में 40 और 50 को जोड़कर इसे बढ़ाया गया है।

5. स्लाइस के साथ काम करना (Working with Slices):

स्लाइस के अंदर के आइटम्स तक भी आप इंडेक्स के माध्यम से पहुँच सकते हैं, ठीक एरे की तरह।

fmt.Println(newSlice[0])  // Access the first element of the slice
newSlice[0] = 25  // Modify the first element of the slice

इस उदाहरण में, newSlice के पहले आइटम को प्रिंट और मॉडिफाई किया गया है।

6. स्लाइस की क्षमता और लंबाई (Capacity and Length of a Slice):

स्लाइस की लंबाई (len) और क्षमता (cap) को जानना उपयोगी होता है। लंबाई बताती है कि स्लाइस में कितने आइटम्स हैं, और क्षमता बताती है कि स्लाइस में अधिकतम कितने आइटम्स स्टोर किए जा सकते हैं।

fmt.Println("Length:", len(numbers))  // Print the length of the slice
fmt.Println("Capacity:", cap(numbers))  // Print the capacity of the slice

इस उदाहरण में, numbers स्लाइस की लंबाई और क्षमता प्रिंट की गई है।

7. स्लाइस को पॉपुलेट करना (Populating a Slice):

आप make फ़ंक्शन का उपयोग करके स्लाइस को इनिशियलाइज़ कर सकते हैं और बाद में इसमें वैल्यूज़ जोड़ सकते हैं।

var cities = make([]string, 3)
cities[0] = "New York"
cities[1] = "Los Angeles"
cities[2] = "Chicago"

इस उदाहरण में, cities नामक एक स्लाइस बनाया गया है, जिसमें तीन शहरों के नाम स्टोर किए गए हैं।

8. स्लाइस और एरे का तुलनात्मक अध्ययन (Comparison of Slices and Arrays):

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

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

मैप्स (Maps)

मैप्स (Maps) गोलैंग में एक शक्तिशाली डेटा स्ट्रक्चर है जो आपको की-वैल्यू (key-value) पेयर्स के रूप में डेटा को संगठित और संग्रहित करने की अनुमति देता है। मैप्स का उपयोग तब किया जाता है जब आपको डेटा को कुंजी के आधार पर स्टोर, एक्सेस, और मैनेज करना हो। गोलैंग में मैप्स का उपयोग करना सरल और प्रभावी है, जिससे आप अपने डेटा को त्वरित और कुशलता से एक्सेस कर सकते हैं।

1. मैप्स का परिचय (Introduction to Maps):

मैप्स एक प्रकार का असोसिएटिव एरे है, जो आपको कुंजी (key) के आधार पर वैल्यू को स्टोर और एक्सेस करने की अनुमति देता है। प्रत्येक कुंजी यूनिक होती है और उसके साथ एक वैल्यू जुड़ी होती है।

var studentGrades map[string]int

इस उदाहरण में, studentGrades नामक एक मैप डिक्लेयर किया गया है, जो स्टूडेंट के नाम (string) को उनकी ग्रेड्स (int) के साथ स्टोर करता है।

2. मैप्स को इनिशियलाइज़ करना (Initializing Maps):

आप मैप्स को make फ़ंक्शन का उपयोग करके इनिशियलाइज़ कर सकते हैं या इसे डिक्लेयर करते समय वैल्यूज के साथ इनिशियलाइज़ कर सकते हैं।

studentGrades = make(map[string]int)

या वैल्यूज के साथ:

studentGrades := map[string]int{
    "Alice": 85,
    "Bob":   90,
    "Carol": 92,
}

इस उदाहरण में, studentGrades नामक मैप डिक्लेयर किया गया है, जिसमें तीन स्टूडेंट्स के नाम और उनकी ग्रेड्स स्टोर की गई हैं।

3. मैप्स में वैल्यूज़ जोड़ना (Adding Values to Maps):

आप मैप्स में नए की-वैल्यू पेयर्स जोड़ सकते हैं या मौजूदा की के साथ नई वैल्यू असाइन कर सकते हैं।

studentGrades["Dave"] = 88

इस उदाहरण में, Dave की के लिए 88 वैल्यू जोड़ी गई है।

4. मैप्स से वैल्यूज़ एक्सेस करना (Accessing Values from Maps):

आप किसी की के माध्यम से मैप्स में स्टोर की गई वैल्यू को एक्सेस कर सकते हैं। यदि की मौजूद नहीं है, तो डिफ़ॉल्ट ज़ीरो वैल्यू लौटाई जाती है।

fmt.Println("Alice's grade:", studentGrades["Alice"])

इस उदाहरण में, Alice की की वैल्यू को एक्सेस करके प्रिंट किया गया है।

5. मैप्स में एंट्री हटाना (Deleting Entries from Maps):

आप मैप्स से किसी की-वैल्यू पेयर को delete फ़ंक्शन का उपयोग करके हटा सकते हैं।

delete(studentGrades, "Bob")

इस उदाहरण में, Bob की के साथ जुड़ी एंट्री को मैप से हटा दिया गया है।

6. मैप्स की लंबाई जांचना (Checking the Length of a Map):

आप len फ़ंक्शन का उपयोग करके मैप्स में स्टोर की गई एंट्रीज़ की संख्या जान सकते हैं।

fmt.Println("Total students:", len(studentGrades))

इस उदाहरण में, studentGrades मैप में स्टोर की गई एंट्रीज़ की कुल संख्या को प्रिंट किया गया है।

7. मैप्स के साथ लूप्स का उपयोग (Using Loops with Maps):

आप for लूप का उपयोग करके मैप्स के सभी की-वैल्यू पेयर्स पर इटरेट कर सकते हैं।

for name, grade := range studentGrades {
    fmt.Printf("%s: %d\n", name, grade)
}

इस उदाहरण में, studentGrades मैप के सभी की-वैल्यू पेयर्स को लूप के माध्यम से इटरेट करके प्रिंट किया गया है।

8. की की मौजूदगी जांचना (Checking for Key Existence):

आप यह जांच सकते हैं कि मैप्स में कोई की मौजूद है या नहीं, और उसके आधार पर उपयुक्त कार्रवाई कर सकते हैं।

grade, exists := studentGrades["Carol"]
if exists {
    fmt.Println("Carol's grade:", grade)
} else {
    fmt.Println("Carol's grade not found.")
}

इस उदाहरण में, Carol की की मौजूदगी की जांच की गई है और यदि वह मौजूद है तो उसकी वैल्यू प्रिंट की गई है।

9. मैप्स के साथ उन्नत ऑपरेशंस (Advanced Operations with Maps):

• डिफ़ॉल्ट वैल्यू: यदि आप किसी की को एक्सेस करते हैं जो मैप्स में मौजूद नहीं है, तो गोलैंग डिफ़ॉल्ट ज़ीरो वैल्यू लौटाता है।
• नील मैप्स (Nil Maps): यदि आप किसी नील मैप पर ऑपरेशन करने का प्रयास करते हैं, तो यह पैनिक नहीं करता है, लेकिन आप वैल्यू असाइन नहीं कर सकते।

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

स्ट्रक्चर और इंटरफेसेस (Structures and Interfaces)

गोलैंग में स्ट्रक्चर (Structures) और इंटरफेसेस (Interfaces) डेटा को संगठित करने और कार्यक्षमता को परिभाषित करने के दो महत्वपूर्ण उपकरण हैं। स्ट्रक्चर का उपयोग डेटा को एक इकाई के रूप में व्यवस्थित करने के लिए किया जाता है, जबकि इंटरफेसेस का उपयोग विभिन्न टाइप्स के बीच सामान्य कार्यों को परिभाषित और लागू करने के लिए किया जाता है।

1. स्ट्रक्चर का परिचय (Introduction to Structures):

स्ट्रक्चर एक कस्टम डेटा टाइप है जो विभिन्न फील्ड्स के समूह को एक साथ रखता है। यह आपको एक ही टाइप के अंतर्गत विभिन्न प्रकार के डेटा को संगठित करने की अनुमति देता है।

type Person struct {
    Name string
    Age  int
    City string
}

इस उदाहरण में, Person नामक एक स्ट्रक्चर डिक्लेयर किया गया है, जिसमें तीन फील्ड्स हैं: Name (string), Age (int), और City (string)।

2. स्ट्रक्चर का उपयोग (Using Structures):

एक बार स्ट्रक्चर डिक्लेयर करने के बाद, आप उसके एक इंस्टेंस को क्रिएट कर सकते हैं और उसमें डेटा असाइन कर सकते हैं।

func main() {
    p1 := Person{Name: "John", Age: 30, City: "New York"}
    fmt.Println(p1)
}

इस उदाहरण में, p1 नामक एक Person स्ट्रक्चर का इंस्टेंस क्रिएट किया गया है, जिसमें John, 30, और New York वैल्यूज स्टोर की गई हैं।

आप स्ट्रक्चर के फील्ड्स तक उनकी पोजीशन के माध्यम से भी पहुँच सकते हैं:

fmt.Println("Name:", p1.Name)
fmt.Println("Age:", p1.Age)
fmt.Println("City:", p1.City)

3. स्ट्रक्चर के साथ मेथड्स का उपयोग (Using Methods with Structures):

स्ट्रक्चर के साथ मेथड्स को परिभाषित किया जा सकता है ताकि आप उस स्ट्रक्चर के डेटा के साथ कार्य कर सकें। मेथड्स का उपयोग स्ट्रक्चर की कार्यक्षमता को बढ़ाने के लिए किया जाता है।

func (p Person) Greet() {
    fmt.Printf("Hello, my name is %s and I am %d years old.\n", p.Name, p.Age)
}

इस उदाहरण में, Greet नामक एक मेथड Person स्ट्रक्चर के लिए परिभाषित किया गया है, जो उस व्यक्ति का परिचय देता है।

4. इंटरफेसेस का परिचय (Introduction to Interfaces):

इंटरफेसेस एक प्रकार का कॉन्ट्रैक्ट होता है जो विभिन्न टाइप्स के लिए सामान्य कार्यों को परिभाषित करता है। यदि कोई टाइप एक इंटरफेस को इम्प्लीमेंट करता है, तो उसे उस इंटरफेस में परिभाषित सभी मेथड्स को लागू करना होगा।

type Speaker interface {
    Speak() string
}

इस उदाहरण में, Speaker नामक एक इंटरफेस डिक्लेयर किया गया है, जिसमें Speak नामक एक मेथड परिभाषित है।

5. इंटरफेसेस का उपयोग (Using Interfaces):

जब कोई टाइप एक इंटरफेस को इम्प्लीमेंट करता है, तो वह टाइप उस इंटरफेस का हिस्सा बन जाता है और उस इंटरफेस के सभी मेथड्स को लागू करना आवश्यक होता है।

type Dog struct {
    Name string
}

func (d Dog) Speak() string {
    return "Woof! My name is " + d.Name
}

इस उदाहरण में, Dog नामक एक टाइप Speaker इंटरफेस को इम्प्लीमेंट करता है और Speak मेथड को लागू करता है।

6. इंटरफेसेस के साथ स्ट्रक्चर्स का उपयोग (Using Interfaces with Structures):

आप इंटरफेस के माध्यम से विभिन्न टाइप्स के लिए एक समान कार्यक्षमता लागू कर सकते हैं। यह आपको लचीला और मॉड्यूलर कोड लिखने में मदद करता है।

func main() {
    var s Speaker
    s = Dog{Name: "Buddy"}
    fmt.Println(s.Speak())
}

इस उदाहरण में, Speaker इंटरफेस का उपयोग Dog टाइप के लिए किया गया है, और Speak मेथड को कॉल किया गया है।

7. इंटरफेस के लाभ (Benefits of Interfaces):

• पॉलीमॉर्फिज्म (Polymorphism): इंटरफेस का उपयोग करके आप विभिन्न टाइप्स को समान इंटरफेस के तहत कार्य करने के लिए बाध्य कर सकते हैं, जिससे कोड अधिक लचीला और पुनः उपयोग करने योग्य हो जाता है।
• कॉन्ट्रैक्ट आधारित प्रोग्रामिंग (Contract-based Programming): इंटरफेस एक प्रकार का कॉन्ट्रैक्ट होता है, जो यह सुनिश्चित करता है कि जो भी टाइप इसे इम्प्लीमेंट करता है, वह आवश्यक मेथड्स को लागू करेगा।

8. नामांकित और अनाम स्ट्रक्चर्स (Named and Anonymous Structures):

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

var person struct {
    Name string
    Age  int
}
person.Name = "Alice"
person.Age = 28

इस उदाहरण में, एक अनाम स्ट्रक्चर डिक्लेयर और उपयोग किया गया है।

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