Arrays in Golang

What are Arrays in Go?

Arrays Go में एक fixed-size sequence होते हैं, जो एक ही type के elements को store करते हैं। Arrays को तब use किया जाता है जब आपको एक known और fixed size का data collection manage करना हो। एक बार array की size निर्धारित हो जाने के बाद उसे change नहीं किया जा सकता।

Basic Syntax for Declaring an Array

Go में array को declare करने के लिए आप निम्नलिखित syntax का उपयोग कर सकते हैं:

var arrayName [size]elementType

arrayName: Array का नाम।

size: Array में कितने elements होंगे, यह size fixed होती है।

elementType: Array में किस type के elements होंगे, यह type को specify करता है।

Example: Declaring an Integer Array

package main

import "fmt"

func main() {
    var numbers [5]int // Declares an array of 5 integers
    fmt.Println("Array:", numbers)
}

Explanation:

• var numbers [5]int: यह statement एक integer array declare करता है जिसमें 5 elements होंगे। Default values सभी elements की 0 होगी।
• Output: "Array: [0 0 0 0 0]"

1. Initializing an Array

Array को declare करने के समय आप उसे initialize भी कर सकते हैं। Initialization का मतलब है कि array के elements को initial values assign करना।

Example: Initializing an Array

package main

import "fmt"

func main() {
    // Initialize an array with specific values
    numbers := [5]int{10, 20, 30, 40, 50}
    fmt.Println("Array:", numbers)
}

Explanation:

• numbers := [5]int{10, 20, 30, 40, 50}: इस statement में array numbers को initialize किया गया है, जिसमें 5 elements हैं, और उनकी initial values 10, 20, 30, 40, और 50 हैं।
• Output: "Array: [10 20 30 40 50]"

2. Array with Implicit Length

Go में आप array की length को implicit रूप से भी declare कर सकते हैं। इसका मतलब है कि आप initialization list के आधार पर array की length को determine करने के लिए Go compiler पर छोड़ सकते हैं।

Example: Array with Implicit Length

package main

import "fmt"

func main() {
    // Array length is inferred from the number of elements
    numbers := [...]int{10, 20, 30, 40, 50}
    fmt.Println("Array:", numbers)
    fmt.Println("Length of array:", len(numbers))
}

Explanation:

• numbers := [...]int{10, 20, 30, 40, 50}: यहां [...] का मतलब है कि array की length initialization list के elements की count के आधार पर infer होगी।
• len(numbers): len() function array की length return करता है।
• Output: "Array: [10 20 30 40 50]" और "Length of array: 5"

3. Accessing and Modifying Array Elements

Array elements को access करने के लिए आप index का उपयोग करते हैं। Go में array indexing 0 से शुरू होती है।

Example: Accessing and Modifying Array Elements

package main

import "fmt"

func main() {
    numbers := [5]int{10, 20, 30, 40, 50}
    
    // Access elements using index
    fmt.Println("First element:", numbers[0])
    fmt.Println("Third element:", numbers[2])
    
    // Modify an element
    numbers[2] = 35
    fmt.Println("Modified array:", numbers)
}

Explanation:

• numbers[0] और numbers[2]: Array के first और third elements को access किया गया है।
• numbers[2] = 35: Third element को modify किया गया है।
• Output: "First element: 10", "Third element: 30", और "Modified array: [10 20 35 40 50]"

4. Iterating Over an Array

Go में for loop और range keyword का उपयोग करके आप arrays के elements को iterate कर सकते हैं।

Example: Iterating Over an Array

package main

import "fmt"

func main() {
    numbers := [5]int{10, 20, 30, 40, 50}
    
    // Using for loop with index
    fmt.Println("Using for loop:")
    for i := 0; i < len(numbers); i++ {
        fmt.Printf("Element at index %d: %d\n", i, numbers[i])
    }
    
    // Using range keyword
    fmt.Println("\nUsing range keyword:")
    for index, value := range numbers {
        fmt.Printf("Element at index %d: %d\n", index, value)
    }
}

Explanation:

• for i := 0; i < len(numbers); i++: Traditional for loop का उपयोग करते हुए array के elements को access किया गया है।
• for index, value := range numbers: range keyword के साथ array के elements और उनके index को access किया गया है।
• Output: "Using for loop:", "Using range keyword:" के साथ सभी elements और उनके indexes print होंगे।

5. Multi-Dimensional Arrays

Go में आप multi-dimensional arrays भी बना सकते हैं। सबसे common प्रकार का multi-dimensional array है 2D array, जो rows और columns का representation होता है।

Example: 2D Array

package main

import "fmt"

func main() {
    // 2D array with 2 rows and 3 columns
    matrix := [2][3]int{
        {1, 2, 3},
        {4, 5, 6},
    }
    
    // Accessing elements
    fmt.Println("Matrix:")
    for i := 0; i < 2; i++ {
        for j := 0; j < 3; j++ {
            fmt.Printf("%d ", matrix[i][j])
        }
        fmt.Println()
    }
}

Explanation:

• matrix := [2][3]int{...}: यह 2D array है जिसमें 2 rows और 3 columns हैं।
• Nested for loop का उपयोग करके array के elements को access और print किया गया है।
• Output: "Matrix:" के साथ 2D array matrix के सभी elements print होंगे।

6. Arrays are Value Types

Go में arrays value types होते हैं, जिसका मतलब है कि जब आप array को किसी दूसरे variable में assign करते हैं या function में pass करते हैं, तो array की एक copy create होती है। Original array में कोई भी change उस copied array को affect नहीं करेगा, और vice versa।

Example: Arrays as Value Types

package main

import "fmt"

func modifyArray(arr [5]int) {
    arr[0] = 100
    fmt.Println("Inside modifyArray function:", arr)
}

func main() {
    numbers := [5]int{10, 20, 30, 40, 50}
    
    modifyArray(numbers)
    fmt.Println("Outside modifyArray function:", numbers)
}

Explanation:

• modifyArray(arr [5]int): यह function array की एक copy को modify करता है, original array को नहीं।
• numbers: जब numbers को function में pass किया जाता है, तो उसकी copy modify होती है।
• Output: "Inside modifyArray function: [100 20 30 40 50]" और "Outside modifyArray function: [10 20 30 40 50]" दिखाएगा कि original array unchanged रहता है।

7. Slices vs Arrays

Arrays और slices में मुख्य अंतर यह है कि slices dynamic होते हैं और उनकी size को runtime पर change किया जा सकता है, जबकि arrays की size fixed होती है। Arrays की fixed size के कारण slices अधिकतर use किए जाते हैं।

Example: Slices (for Comparison)

package main

import "fmt"

func main() {
    numbers := []int{10, 20, 30, 40, 50} // Slice
    fmt.Println("Slice:", numbers)
}

Explanation:

• numbers := []int{10, 20, 30, 40, 50}: यह slice declaration है, जो कि array के बिना fixed size के होता है।

Summary

• Arrays: Fixed-size sequence of elements of the same type।
• Declaration and Initialization: Arrays को declare और initialize किया जा सकता है, और initialization के समय उनकी length को infer किया जा सकता है।
• Accessing and Modifying: Array elements को उनके index के द्वारा access और modify किया जा सकता है।
• Iteration: Arrays के elements को iterate करने के लिए for loop और range keyword का उपयोग किया जा सकता है।
• Multi-Dimensional Arrays: Go में multi-dimensional arrays का उपयोग complex data structures के लिए किया जा सकता है।
• Value Types: Arrays value types होते हैं, यानी कि वे function में pass होने पर या assignment के दौरान copy होते हैं।
• Slices vs Arrays: Slices dynamic होते हैं और arrays की तुलना में अधिक flexible होते हैं।

Go में arrays का उपयोग basic और fixed-size data collections के लिए किया जाता है। अगर आपको arrays के बारे में और जानकारी चाहिए या कोई specific सवाल है, तो बताइए!

Previous Next