गोलैंग अर्रे और स्लाइसिंग सीखें

गो भाषा में एरे

1.1 ऐरे की परिभाषा और घोषणा

एक एरे एक स्थिर-आकार के तत्वों का एक क्रम है जिनका सामान्य रूप से एक ही प्रकार होता है। गो भाषा में, ऐरे की लंबाई को एरे प्रकार का एक हिस्सा माना जाता है। इसका मतलब है कि विभिन्न लंबाई के एरे को अलग-अलग प्रकार के रूप में देखा जाता है।

एरे की घोषणा के लिए मूल संकेत निम्नलिखित है:

var arr [n]T

यहां, var चरण चिन्ह है परिवर्तनीय की घोषणा के लिए, arr ऐरे का नाम है, n ऐरे की लंबाई को प्रस्तुत करता है, और T ऐरे में तत्वों का प्रकार प्रस्तुत करता है।

उदाहरण के लिए, 5 पूर्णांक समायोजित करने के लिए:

var myArray [5]int

इस उदाहरण में, myArray एक ऐरे है जो पूर्णांक प्रकार के 5 पूर्णांकों को समायोजित कर सकता है।

1.2 आरंभ और प्रयोग की प्रक्रिया

एरे की प्रारंभिककरण सीधे घोषणा के दौरान या सूचियों का संदर्भांकन करके किया जा सकता है। ऐरे की प्रारंभिकीकरण के लिए कई विधियाँ हैं:

सीधी प्रारंभीकरण

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

संख्या-initialized मानों की संख्या के आधार पर ऐरे की लंबाई compiler द्वारा निर्धारित करने की संभावना भी है:

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

यहां, ... इसका सूचना करता है कि ऐरे की लंबाई compiler द्वारा गणना की जाती है।

सूचियों का प्रयोग

var myArray [5]int
myArray[0] = 10
myArray[1] = 20
// शेष तत्व 0 के रूप में स्वत: अपनी प्रारंभिकीकरण की जाती है, क्योंकि int की शून्य मूल्य है 0

ऐरे का प्रयोग भी सरल है, और तत्वों को सूचियों का उपयोग करके पहुँचा जा सकता है:

fmt.Println(myArray[2]) // तीसरे तत्व का पहुँच

1.3 ऐरे-चरण

ऐरे-चरण के लिए दो सामान्य विधियाँ हैं: पारंपरिक for लूप का प्रयोग करना और range का उपयोग करना।

for लूप का उपयोग करके चरण

for i := 0; i < len(myArray); i++ {
    fmt.Println(myArray[i])
}

range का प्रयोग करके चरण

for index, value := range myArray {
    fmt.Printf("Index: %d, Value: %d\n", index, value)
}

range का उपयोग करने का लाभ यह है कि यह दो मूल्यों को वापस करता है: वर्तमान सूची स्थान और उस स्थान पर मौजूद मूल्य।

1.4 ऐरे की विशेषताएँ और सीमाएँ

गो भाषा में, ऐरे मूल्य प्रकार होते हैं, जिसका मतलब होता है कि जब एक ऐरे को किसी समान्य के पैरामीटर के रूप में पास किया जाता है, तो एक ऐरे की कॉपी को पास किया जाता है। इसलिए, अगर किसी समान्य के लिए मूल सूची संशोधन की आवश्यकता होती है, तो सामान्यत: स्लाइस या ऐरे के पॉइंटर का उपयोग किया जाता है।

2 गो भाषा में स्लाइस

2.1 स्लाइस की अवधारणा

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

• गतिशील आकार: ऐरे की तुलना में, स्लाइस की लंबाई गतिशील होती है, जिसकी वजह से यह जरूरत के अनुसार स्वचालित रूप से बढ़ती या कम हो सकती है।
• लचीलापन: सुरक्षा-अंक सहायता से स्लाइस में आसानी से मैश किया जा सकता है.
• संदर्भ प्रकार: स्लाइस डेटा की प्रमुख्य ऐरे के संदर्भ में पहुँच करते हैं, बिना डेटा की प्रतिलिपि बनाए।

2.2 स्लाइस की घोषणा और प्रारंभीकरण

स्लाइस की घोषणा के लिए संकेत एक ऐरे के घोषणा के समान है, लेकिन जब घोषणा करते समय आपको तत्वों की संख्या को स्पष्ट करने की आवश्यकता नहीं होती है। उदाहरण के लिए, पूर्णांकों के एक स्लाइस की घोषणा निम्नलिखित तरीके से की जा सकती है:

var slice []int

आप एक स्लाइस को एक स्लाइस सूचक का प्रयोग करके प्रारंभिक कर सकते हैं:

slice := []int{1, 2, 3}

आप एक स्लाइस को make फ़ंक्शन का प्रयोग करके प्रारंभिक कर सकते हैं, जिसके माध्यम से आप स्लाइस की लंबाई और क्षमता को निर्धारित कर सकते हैं:

slice := make([]int, 5)  // 5 पूर्णांकों का एक स्लाइस बनाएं

अधिक क्षमता की आवश्यकता होने पर, आप make फ़ंक्शन के तीसरे पैरामीटर के रूप में क्षमता को पास कर सकते हैं:

slice := make([]int, 5, 10)  // 5 की लंबाई और 10 की क्षमता वाला एक पूर्णांक स्लाइस बनाएं

2.3 स्लाइस और अर्रे के बीच संबंध

स्लाइस एक अर्रे के सेगमेंट को निर्दिष्ट करके बनाए जा सकते हैं, जिससे उस सेगमेंट का संदर्भ बनाया जाता है। उदाहरण के रूप में, निम्नलिखित अर्रे को दिया गया है:

array := [5]int{10, 20, 30, 40, 50}

हम निम्नलिखित रूप में एक स्लाइस बना सकते हैं:

slice := array[1:4]

यह स्लाइस slice अर्रे array के तत्वों का संदर्भ करेगा, जो सूचक 1 से सूचक 3 (सूचक 1 से सूचक 4 तक समाविष्ट है, लेकिन सूचक 4 समाविष्ट नहीं है।)

यह जरूरी है कि स्लाइस वास्तव में अर्रे के मानों को कॉपी नहीं करता है; यह केवल मूल अर्रे के एक सतत सेगमेंट को इंगित करता है। इसलिए, स्लाइस में परिवर्तन भी मूल अर्रे को प्रभावित करेगा, और उल्टा भी। इस संदर्भ संबंध को समझना, स्लाइस का प्रभावी ढंग से उपयोग करने के लिए महत्वपूर्ण है।

2.4 स्लाइस पर मौलिक ऑपरेशन

2.4.1 इंडेक्सिंग

स्लाइस अपने तत्वों तक पहुँचने के लिए सूचकों का उपयोग करते हैं, जो अर्रे की तरह 0 से शुरू होता है। उदाहरण के रूप में:

slice := []int{10, 20, 30, 40}
// पहला और तीसरा तत्व तक पहुँचना
fmt.Println(slice[0], slice[2])

2.4.2 लंबाई और क्षमता

स्लाइस के दो गुण: लंबाई (len) और क्षमता (cap) होती है। लंबाई स्लाइस में तत्वों की संख्या होती है, और क्षमता स्लाइस के पहले तत्व से इसके मूल अर्रे के अंत तक के तत्वों की संख्या होती है।

slice := []int{10, 20, 30, 40}
// स्लाइस की लंबाई और क्षमता को प्रिंट करना
fmt.Println(len(slice), cap(slice))

2.4.3 तत्वों को जोड़ना

append फ़ंक्शन का उपयोग स्लाइस में तत्वों को जोड़ने के लिए किया जाता है। जब स्लाइस की क्षमता नए तत्वों को समायोजित करने के लिए पर्याप्त नहीं होती है, तो append फ़ंक्शन स्वचालित रूप से स्लाइस की क्षमता का विस्तार करता है।

slice := []int{10, 20, 30}
// एक तत्व जोड़ना
slice = append(slice, 40)
// एक से अधिक तत्व जोड़ना
slice = append(slice, 50, 60)
fmt.Println(slice)

यह जरूरी है कि append का उपयोग करते समय तत्वों को जोड़ने पर, यह एक नई स्लाइस वापस भी लौट सकता है। यदि मूल अर्रे की क्षमता पर्याप्त नहीं है, तो append ऑपरेशन से स्लाइस को एक नए, बड़े अर्रे को इंगित करने पर वापस ले जाएगा।

2.5 स्लाइस का विस्तार और कॉपी करना

copy फ़ंक्शन का उपयोग एक स्लाइस के तत्वों को दूसरी स्लाइस में कॉपी करने के लिए किया जा सकता है। लक्ष्य स्लाइस को पहले से ही काफी जगह आवंटित कर लेना चाहिए और यह ऑपरेशन लक्ष्य स्लाइस की क्षमता को नहीं बदलेगा।

2.5.1 copy फ़ंक्शन का उपयोग करना

निम्नलिखित कोड दिखाता है कि copy को कैसे उपयोग किया जाता है:

src := []int{1, 2, 3}
dst := make([]int, 3)
// तत्वों को लक्ष्य स्लाइस में कॉपी करना
copied := copy(dst, src)
fmt.Println(dst, copied)

copy फ़ंक्शन वापस किए गए तत्वों की संख्या देता है, और यह लक्ष्य स्लाइस की लंबाई या स्रोत स्लाइस की लंबाई से अधिक नहीं होगी, जिस भी छोटी हो।

2.5.2 विचारात्मक

copy फ़ंक्शन का उपयोग करते समय, यदि नए तत्व जोड़े जाते हैं लेकिन लक्ष्य स्लाइस में पर्याप्त जगह नहीं होती है, तो केवल उन तत्वों को कॉपी किया जाएगा जो लक्ष्य स्लाइस समायोजित कर सकती है।

2.6 बहु-आयामी स्लाइस

बहु-आयामी स्लाइस एक स्लाइस है जो कई स्लाइस को शामिल करती है। यह एक बहु-आयामी अर्रे के अनुरूप है, लेकिन स्लाइस की चरम लंबाई के कारण, बहु-आयामी स्लाइस और लचीली होती है।

2.6.1 बहु-आयामी स्लाइस बनाना

दो-आयामी स्लाइस (स्लाइस का स्लाइस) बनाने का तरीका:

twoD := make([][]int, 3)
for i := 0; i < 3; i++ {
    twoD[i] = make([]int, 3)
    for j := 0; j < 3; j++ {
        twoD[i][j] = i + j
    }
}
fmt.Println("दो-आयामी स्लाइस: ", twoD)

2.6.2 बहु-आयामी स्लाइस का उपयोग

बहु-आयामी स्लाइस का उपयोग एक-आयामी स्लाइस का उपयोग करने जैसा होता है, सूचक द्वारा पहुँचा जाता है:

// दो-आयामी स्लाइस के तत्वों तक पहुँचना
val := twoD[1][2]
fmt.Println(val)

3 अर्रे और स्लाइस अनुप्रयोगों की तुलना

3.1 उपयोग स्थिति की तुलना

Go में arrays और slices दोनों ही एक ही प्रकार के डेटा को स्टोर करने के लिए प्रयोग किए जाते हैं, लेकिन उनके उपयोग स्थिति में विशेष भेद होते हैं।

Arrays:

• एक array की लंबाई घोषणा पर निर्धारित होती है, जिससे यह स्थिर अंकों की जानी गई, निश्चित संख्या के तत्वों को स्टोर करने के लिए उपयुक्त होता है।
• जब एक ऐसा कंटेनर चाहिए जिसका आकार निश्चित होता है, जैसे कि एक निश्चित आकार का मैट्रिक्स का प्रतिनिधित्व करना, तो array सबसे अच्छा विकल्प होता है।
• Arrays को स्टैक पर आवंटित किया जा सकता है, जिससे जब array का आकार बड़ा नहीं हो, तो उच्च प्रदर्शन प्राप्त करने का सुअवोधान होता है।

Slices:

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

सारांश में, arrays निश्चित आकार की आवश्यकताओं के लिए उपयुक्त होते हैं, जो Go की स्टैटिक मेमोरी प्रबंधन विशेषताओं को दर्शाते हैं, जबकि slices और विकस्त होते हैं, जो arrays की एक अभिव्यक्ति में में, वास्तविक में उपयुक्त होती है, विस्तृत संग्रह के साथ काम करने के लिए।