Slices in Golang

What are Slices in Go?

Slices Go में एक dynamic, flexible, और powerful data structure है जो arrays के ऊपर built होता है। Slices arrays का एक lightweight abstraction हैं, लेकिन slices की size runtime पर change हो सकती है। यह feature slices को arrays के मुकाबले ज्यादा useful और practical बनाता है। Slices Go में सबसे commonly used data structures में से एक हैं।

Basic Syntax for Declaring a Slice

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

• Using []T syntax
• Using make() function
• Slicing an existing array or slice

Example: Declaring a Slice

package main

import "fmt"

func main() {
    // Declaring a slice using []T syntax
    var numbers []int
    fmt.Println("Empty slice:", numbers)

    // Declaring and initializing a slice
    numbers = []int{10, 20, 30, 40, 50}
    fmt.Println("Initialized slice:", numbers)
}

Explanation:

• var numbers []int: यह slice declaration है। यह initially nil है, यानी empty slice है।
• numbers = []int{10, 20, 30, 40, 50}: यहां slice को initialize किया गया है। Slices की size dynamic होती है, और यहां इसे 5 elements के साथ initialize किया गया है।

1. Slicing an Array or Slice

Slices का सबसे common और powerful feature है कि आप एक existing array या slice से एक new slice बना सकते हैं। इस process को slicing कहते हैं।

Example: Slicing an Array

package main

import "fmt"

func main() {
    // Array declaration
    array := [5]int{10, 20, 30, 40, 50}

    // Slicing the array to create a slice
    slice := array[1:4] // Includes elements at index 1, 2, 3
    fmt.Println("Original array:", array)
    fmt.Println("Sliced portion:", slice)
}

Explanation:

• array[1:4]: यह slicing operation array के index 1 से शुरू होकर 4 से पहले तक के elements को include करता है (i.e., elements at index 1, 2, और 3)।
• Output: "Original array: [10 20 30 40 50]" और "Sliced portion: [20 30 40]"

2. Length and Capacity of a Slice

Slices की दो important properties होती हैं: Length (len) और Capacity (cap).

• Length: Slice में कितने elements हैं, इसे define करता है।
• Capacity: Slice की underlying array में कितनी elements को hold करने की capacity है, इसे define करता है।

Example: Length and Capacity

package main

import "fmt"

func main() {
    // Array and slicing
    array := [5]int{10, 20, 30, 40, 50}
    slice := array[1:4] // Slice includes elements at index 1, 2, 3

    fmt.Println("Slice:", slice)
    fmt.Println("Length of slice:", len(slice))
    fmt.Println("Capacity of slice:", cap(slice))
}

Explanation:

• len(slice): Slice की length को return करता है। यहां, length 3 है।
• cap(slice): Slice की capacity को return करता है। Capacity उस position से लेकर underlying array के last element तक की होती है जहां से slice शुरू होती है। यहां, capacity 4 है।

3. Using make() Function to Create Slices

Go में आप make() function का उपयोग करके slices create कर सकते हैं। यह function आपको slice की initial length और capacity specify करने की सुविधा देता है।

Example: Creating a Slice with make()

package main

import "fmt"

func main() {
    // Creating a slice with make()
    numbers := make([]int, 5, 10)
    fmt.Println("Slice:", numbers)
    fmt.Println("Length:", len(numbers))
    fmt.Println("Capacity:", cap(numbers))
}

Explanation:

• make([]int, 5, 10): यह statement एक integer slice create करता है जिसकी initial length 5 और capacity 10 होती है।
• Output: "Slice: [0 0 0 0 0]", "Length: 5", और "Capacity: 10"

4. Appending to a Slice

Slices में आप dynamically elements add कर सकते हैं, जिसके लिए append() function का उपयोग किया जाता है। अगर slice की capacity exceed हो जाती है, तो Go internally new, larger array allocate करता है और old array के elements को new array में copy कर देता है।

Example: Appending to a Slice

package main

import "fmt"

func main() {
    // Initial slice
    numbers := []int{10, 20, 30}
    
    // Appending elements to the slice
    numbers = append(numbers, 40, 50)
    fmt.Println("Slice after appending:", numbers)
    fmt.Println("New Length:", len(numbers))
    fmt.Println("New Capacity:", cap(numbers))
}

Explanation:

• append(numbers, 40, 50): यह statement slice numbers में दो new elements (40 और 50) add करता है।
• Output: "Slice after appending: [10 20 30 40 50]", "New Length: 5", और "New Capacity" updated हो सकती है।

5. Copying Slices

Go में slices को copy करने के लिए copy() function का उपयोग किया जाता है। यह function source slice के elements को destination slice में copy करता है।

Example: Copying a Slice

package main

import "fmt"

func main() {
    // Source slice
    source := []int{10, 20, 30}

    // Destination slice (with enough capacity)
    dest := make([]int, len(source))

    // Copying the source slice to the destination slice
    copy(dest, source)
    fmt.Println("Source slice:", source)
    fmt.Println("Destination slice after copy:", dest)
}

Explanation:

• copy(dest, source): यह function source slice के elements को destination slice में copy करता है।
• Output: "Source slice: [10 20 30]" और "Destination slice after copy: [10 20 30]"

6. Slices are Reference Types

Slices reference types होते हैं, जिसका मतलब है कि जब आप एक slice को किसी दूसरे variable में assign करते हैं या function में pass करते हैं, तो underlying array की reference pass होती है, ना कि slice की copy।

Example: Slices as Reference Types

package main

import "fmt"

func modifySlice(s []int) {
    s[0] = 100
}

func main() {
    numbers := []int{10, 20, 30}
    modifySlice(numbers)
    fmt.Println("Modified slice:", numbers)
}

Explanation:

• modifySlice(s []int): यह function slice को modify करता है। चूंकि slices reference types होते हैं, यह original slice को भी modify कर देगा।
• Output: "Modified slice: [100 20 30]"

7. Multi-Dimensional Slices

Go में आप multi-dimensional slices भी बना सकते हैं, जो कि slices का slices होते हैं।

Example: Multi-Dimensional Slices

package main

import "fmt"

func main() {
    // 2D slice (slice of slices)
    matrix := [][]int{
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9},
    }

    fmt.Println("2D Slice (Matrix):")
    for _, row := range matrix {
        fmt.Println(row)
    }
}

Explanation:

• matrix := [][]int{...}: यह 2D slice है, जिसमें slices के अंदर slices होते हैं।
• Output: "2D Slice (Matrix):" के साथ सभी rows और उनके elements print होंगे।

Summary

• Slices: Go में dynamic arrays होते हैं जिनकी size runtime पर change हो सकती है।
• Slicing: आप existing arrays या slices से slices बना सकते हैं।
• Length and Capacity: Slices की length और capacity होती है, जो कि slicing या append operations के दौरान change हो सकती है।
• make() Function: इसका उपयोग करके आप slices create कर सकते हैं, जिनकी length और capacity आप specify कर सकते हैं।
• Appending: append() function के माध्यम से आप slices में dynamically elements add कर सकते हैं।
• Copying: copy() function का उपयोग करके slices के elements को एक से दूसरे slice में copy किया जा सकता है।
• Reference Types: Slices reference types होते हैं, यानी कि वे underlying array को reference करते हैं।
• Multi-Dimensional Slices: Go में आप multi-dimensional slices बना सकते हैं, जो complex data structures को represent करने के लिए उपयोगी होते हैं।

Slices Go में arrays की flexibility को बढ़ाते हैं, और उन्हें समझना और effectively use करना Go programming में बहुत महत्वपूर्ण है। अगर आपको slices के बारे में और जानकारी चाहिए या कोई specific सवाल है, तो बताइए!

Previous Next