Maps in Golang

What are Maps in Go?

Maps Go में key-value pairs को store करने के लिए एक built-in data structure हैं। Maps का उपयोग तब किया जाता है जब आपको unique keys के साथ values को associate करना हो। हर key का value के साथ एक unique association होता है, और आप keys का उपयोग करके values को efficiently retrieve कर सकते हैं।

Basic Syntax for Declaring a Map

Go में map को declare और initialize करने के कई तरीके हैं:

• Using make() function
• Using map literals

Example: Declaring a Map

package main

import "fmt"

func main() {
    // Declaring a map using make()
    var studentGrades map[string]int
    studentGrades = make(map[string]int)

    // Declaring and initializing a map using map literals
    studentGrades = map[string]int{
        "Alice": 90,
        "Bob":   85,
        "Charlie": 88,
    }
    fmt.Println("Student Grades:", studentGrades)
}

Explanation:

• var studentGrades map[string]int: यह एक map declaration है, जहां keys string type के हैं और values int type की हैं। Initially, यह nil है।
• make(map[string]int): यह statement map को initialize करता है। यह एक empty map return करता है।
• map[string]int{...}: यह map literal syntax है, जहां map को keys और values के साथ initialize किया गया है।

1. Adding and Updating Elements in a Map

आप आसानी से maps में new key-value pairs add कर सकते हैं और existing keys की values को update कर सकते हैं।

Example: Adding and Updating Elements

package main

import "fmt"

func main() {
    // Initializing a map
    studentGrades := map[string]int{
        "Alice": 90,
        "Bob":   85,
    }
    
    // Adding a new key-value pair
    studentGrades["Charlie"] = 88
    
    // Updating an existing key's value
    studentGrades["Bob"] = 92

    fmt.Println("Updated Student Grades:", studentGrades)
}

Explanation:

• studentGrades["Charlie"] = 88: यह statement एक new key "Charlie" और उसकी value 88 को map में add करता है।
• studentGrades["Bob"] = 92: यह statement existing key "Bob" की value को 85 से update करके 92 कर देता है।
• Output: "Updated Student Grades: map[Alice:90 Bob:92 Charlie:88]"

2. Accessing Elements in a Map

आप map में किसी भी key का उपयोग करके उसके corresponding value को access कर सकते हैं। अगर key exist नहीं करती, तो map default zero value return करेगा।

Example: Accessing Elements

package main

import "fmt"

func main() {
    // Initializing a map
    studentGrades := map[string]int{
        "Alice": 90,
        "Bob":   85,
        "Charlie": 88,
    }
    
    // Accessing elements
    aliceGrade := studentGrades["Alice"]
    fmt.Println("Alice's Grade:", aliceGrade)
    
    // Accessing a non-existing key
    unknownGrade := studentGrades["David"]
    fmt.Println("David's Grade (non-existing):", unknownGrade)
}

Explanation:

• studentGrades["Alice"]: यह statement "Alice" की value को retrieve करता है, जो 90 है।
• studentGrades["David"]: चूंकि "David" map में exist नहीं करता, इसलिए Go zero value (for int, it's 0) return करता है।
• Output: "Alice's Grade: 90" और "David's Grade (non-existing): 0"

3. Checking if a Key Exists

Map में किसी key के existence को check करने के लिए आप comma ok idiom का उपयोग कर सकते हैं। यह आपको बताता है कि क्या key map में exist करती है और अगर करती है, तो उसकी value क्या है।

Example: Checking if a Key Exists

package main

import "fmt"

func main() {
    // Initializing a map
    studentGrades := map[string]int{
        "Alice": 90,
        "Bob":   85,
    }
    
    // Check if a key exists
    grade, exists := studentGrades["Alice"]
    if exists {
        fmt.Println("Alice's Grade:", grade)
    } else {
        fmt.Println("Alice's Grade not found")
    }

    // Check for a non-existing key
    grade, exists = studentGrades["David"]
    if exists {
        fmt.Println("David's Grade:", grade)
    } else {
        fmt.Println("David's Grade not found")
    }
}

Explanation:

• grade, exists := studentGrades["Alice"]: यह statement "Alice" की value को retrieve करता है और exists को true set करता है क्योंकि key exist करती है।
• grade, exists = studentGrades["David"]: "David" key exist नहीं करती, इसलिए exists false set होता है।
• Output: "Alice's Grade: 90" और "David's Grade not found"

4. Deleting Elements from a Map

Maps से elements को delete करने के लिए आप delete() function का उपयोग कर सकते हैं। यह function key को remove करता है और अगर key exist नहीं करती, तो कोई error नहीं होती।

Example: Deleting an Element

package main

import "fmt"

func main() {
    // Initializing a map
    studentGrades := map[string]int{
        "Alice": 90,
        "Bob":   85,
        "Charlie": 88,
    }
    
    // Deleting an element
    delete(studentGrades, "Bob")
    
    fmt.Println("After deleting Bob:", studentGrades)
}

Explanation:

• delete(studentGrades, "Bob"): यह statement "Bob" key और उसकी value को map से delete कर देता है।
• Output: "After deleting Bob: map[Alice:90 Charlie:88]"

5. Iterating Over a Map

आप range keyword का उपयोग करके map के सभी key-value pairs पर iterate कर सकते हैं। Maps में iteration का order guaranteed नहीं होता है, यानी कि हर execution पर iteration का order different हो सकता है।

Example: Iterating Over a Map

package main

import "fmt"

func main() {
    // Initializing a map
    studentGrades := map[string]int{
        "Alice": 90,
        "Bob":   85,
        "Charlie": 88,
    }
    
    // Iterating over the map
    fmt.Println("Student Grades:")
    for name, grade := range studentGrades {
        fmt.Printf("%s: %d\n", name, grade)
    }
}

Explanation:

• for name, grade := range studentGrades: यह loop map के सभी key-value pairs पर iterate करता है और उन्हें print करता है।
• Output: "Student Grades:" के साथ सभी students और उनके grades print होंगे, लेकिन order guaranteed नहीं होता।

6. Maps are Reference Types

Maps reference types होते हैं, यानी कि जब आप map को किसी दूसरे variable में assign करते हैं या function में pass करते हैं, तो map की reference pass होती है, ना कि map की copy। इसका मतलब है कि अगर आप map को modify करते हैं, तो वो सभी references में reflect होगा।

Example: Maps as Reference Types

package main

import "fmt"

func modifyMap(m map[string]int) {
    m["Alice"] = 95
}

func main() {
    studentGrades := map[string]int{
        "Alice": 90,
        "Bob":   85,
    }

    modifyMap(studentGrades)
    fmt.Println("Modified Student Grades:", studentGrades)
}

Explanation:

• modifyMap(m map[string]int): यह function map को modify करता है। चूंकि maps reference types होते हैं, यह modification original map को भी affect करेगा।
• Output: "Modified Student Grades: map[Alice:95 Bob:85]"

7. Nested Maps

आप Go में nested maps भी बना सकते हैं, जहां एक map की value एक और map हो सकती है। यह complex data structures को represent करने के लिए उपयोगी है।

Example: Nested Maps

package main

import "fmt"

func main() {
    // Nested map
    departments := map[string]map[string]int{
        "Sales": {
            "Alice": 50000,
            "Bob":   60000,
        },
        "Engineering": {
            "Charlie": 70000,
            "David":   80000,
        },
    }

    fmt.Println("Departments:")
    for dept, employees := range departments {
        fmt.Println(dept)
        for name, salary := range employees {
            fmt.Printf("  %s: %d\n", name, salary)
        }
    }
}

Explanation:

• departments := map[string]map[string]int{...}: यह nested map declaration है, जहां एक department name (string) एक nested map को reference करता है, जो employees के नाम और उनकी salaries को hold करता है।
• Output: सभी departments और उनके employees के names और salaries को hierarchical structure में print करेगा।

Summary

• Maps: Key-value pairs को store करने के लिए built-in data structure है। Keys unique होती हैं और values keys के साथ associated होती हैं।
• Declaring and Initializing: Maps को make() function या map literals के द्वारा declare और initialize किया जा सकता है।
• Adding, Updating, and Deleting: Maps में आप आसानी से key-value pairs को add, update, और delete कर सकते हैं।
• Accessing Elements: आप keys का उपयोग करके maps से values को access कर सकते हैं।
• Checking Existence: Comma ok idiom का उपयोग करके आप check कर सकते हैं कि कोई key map में exist करती है या नहीं।
• Iteration: आप range keyword का उपयोग करके map के सभी key-value pairs पर iterate कर सकते हैं।
• Reference Types: Maps reference types होते हैं, यानी कि वे underlying data structure को reference करते हैं।
• Nested Maps: Maps के अंदर maps का उपयोग करके complex data structures represent किए जा सकते हैं।

Maps Go में बहुत powerful और flexible data structures हैं, और उन्हें effectively use करना Go programming में mastery हासिल करने के लिए महत्वपूर्ण है। अगर आपको maps के बारे में और जानकारी चाहिए या कोई specific सवाल है, तो बताइए!

Previous Next