Go
स्लाइस

परिचय

वाक्य - विन्यास

• टुकड़ा: = बनाना ([] प्रकार, लेन, टोपी) // एक नया टुकड़ा बनाएँ
• slice = append (स्लाइस, आइटम) // किसी आइटम को स्लाइस में जोड़ें
• slice = append (स्लाइस, आइटम ...) // एक स्लाइस के लिए आइटम का टुकड़ा जोड़ें
• len: = len (slice) // एक स्लाइस की लंबाई प्राप्त करें
• cap: = cap (स्लाइस) // एक स्लाइस की क्षमता प्राप्त करें
• elNum: = copy (dst, slice) // एक स्लाइस की सामग्री को दूसरे स्लाइस में कॉपी करें

टुकड़ा करने के लिए आवेदन करना

slice = append(slice, "hello", "world")

एक साथ दो स्लाइस जोड़ना

slice1 := []string{"!"}
slice2 := []string{"Hello", "world"}
slice  := append(slice1, slice2...)

गो खेल के मैदान में दौड़ें

तत्वों को हटाने / "स्लाइसिंग" स्लाइस

यदि आपको एक स्लाइस से एक या एक से अधिक तत्वों को निकालने की आवश्यकता है, या यदि आपको किसी अन्य मौजूदा एक उप स्लाइस के साथ काम करने की आवश्यकता है; आप निम्न विधि का उपयोग कर सकते हैं।

निम्नलिखित उदाहरण इंट के स्लाइस का उपयोग करते हैं, लेकिन यह सभी प्रकार के स्लाइस के साथ काम करता है।

तो इसके लिए, हमें एक स्लाइस की आवश्यकता है, चुड़ैल से हम कुछ तत्वों को निकाल देंगे:

slice := []int{1, 2, 3, 4, 5, 6} 
// > [1 2 3 4 5 6]

हमें हटाने के लिए तत्वों के अनुक्रमित की भी आवश्यकता है:

// index of first element to remove (corresponding to the '3' in the slice)
var first = 2

// index of last element to remove (corresponding to the '5' in the slice)
var last = 4 

और इसलिए हम अवांछनीय तत्वों को हटाते हुए, स्लाइस को "स्लाइस" कर सकते हैं:

// keeping elements from start to 'first element to remove' (not keeping first to remove), 
// removing elements from 'first element to remove' to 'last element to remove'
// and keeping all others elements to the end of the slice
newSlice1 := append(slice[:first], slice[last+1:]...)
// > [1 2 6]

// you can do using directly numbers instead of variables
newSlice2 := append(slice[:2], slice[5:]...)
// > [1 2 6]

// Another way to do the same
newSlice3 := slice[:first + copy(slice[first:], slice[last+1:])]
// > [1 2 6]

// same that newSlice3 with hard coded indexes (without use of variables)
newSlice4 := slice[:2 + copy(slice[2:], slice[5:])]
// > [1 2 6]

केवल एक तत्व को निकालने के लिए, बस इस तत्व के सूचकांक को पहले और अंतिम सूचकांक के रूप में निकालना होगा, जैसे:

var indexToRemove = 3
newSlice5 := append(slice[:indexToRemove], slice[indexToRemove+1:]...)
// > [1 2 3 5 6]

// hard-coded version:
newSlice5 := append(slice[:3], slice[4:]...)
// > [1 2 3 5 6]

और आप स्लाइस की शुरुआत से तत्वों को भी हटा सकते हैं:

newSlice6 := append(slice[:0], slice[last+1:]...)
// > [6]

// That can be simplified into
newSlice6 := slice[last+1:]
// > [6]

आप स्लाइस के अंत से कुछ तत्व भी निकाल सकते हैं:

newSlice7 := append(slice[:first], slice[first+1:len(slice)-1]...)
// > [1 2]

// That can be simplified into
newSlice7 := slice[:first]
// > [1 2]

यदि नए स्लाइस में पहले वाले की तुलना में बिल्कुल समान तत्व शामिल हैं, तो आप एक ही चीज़ का उपयोग कर सकते हैं, लेकिन last := first-1 साथ last := first-1 ।
(यह आपके अनुक्रमित होने की स्थिति में उपयोगी हो सकता है)

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

स्लाइस की लंबाई और क्षमता दोनों होती है। एक स्लाइस की लंबाई वर्तमान में स्लाइस में तत्वों की संख्या है, जबकि क्षमता उन तत्वों की संख्या है जिन्हें स्लाइस को वास्तविक बनाने की आवश्यकता से पहले पकड़ सकते हैं ।

अंतर्निहित make() फ़ंक्शन का उपयोग करके एक स्लाइस make() , आप इसकी लंबाई निर्दिष्ट कर सकते हैं, और वैकल्पिक रूप से इसकी क्षमता। यदि क्षमता स्पष्ट रूप से निर्दिष्ट नहीं है, तो यह निर्दिष्ट लंबाई होगी।

var s = make([]int, 3, 5) // length 3, capacity 5

आप बिल्ट-इन len() फ़ंक्शन के साथ एक स्लाइस की लंबाई की जांच कर सकते हैं:

var n = len(s) // n == 3

आप अंतर्निहित cap() फ़ंक्शन के साथ क्षमता की जांच कर सकते हैं:

var c = cap(s) // c == 5

make() तत्व make() स्लाइस के तत्व प्रकार के लिए शून्य मान पर सेट होते हैं:

for idx, val := range s {
    fmt.Println(idx, val)
}
// output:
// 0 0
// 1 0
// 2 0

इसे play.golang.org पर चलाएं

आप एक स्लाइस की लंबाई से परे तत्वों तक नहीं पहुंच सकते हैं, भले ही सूचकांक क्षमता के भीतर हो:

var x = s[3] // panic: runtime error: index out of range

हालाँकि, जब तक क्षमता लंबाई से अधिक हो जाती है, तब तक आप नए तत्वों को पुनः प्राप्त किए बिना जोड़ सकते हैं:

var t = []int{3, 4}
s = append(s, t) // s is now []int{0, 0, 0, 3, 4}
n = len(s) // n == 5
c = cap(s) // c == 5

यदि आप एक ऐसे स्लाइस में भाग लेते हैं जिसमें नए तत्वों को स्वीकार करने की क्षमता का अभाव है, तो अंतर्निहित सरणी आपके लिए पर्याप्त क्षमता के साथ पुनः प्राप्त हो जाएगी:

var u = []int{5, 6}
s = append(s, u) // s is now []int{0, 0, 0, 3, 4, 5, 6}
n = len(s) // n == 7
c = cap(s) // c > 5

इसलिए, आमतौर पर अच्छा अभ्यास पर्याप्त क्षमता आवंटित करने के लिए होता है जब पहली बार एक स्लाइस बनाते हैं, अगर आपको पता है कि अनावश्यक वास्तविकताओं से बचने के लिए आपको कितनी जगह की आवश्यकता होगी।

सामग्री को एक स्लाइस से दूसरे स्लाइस में कॉपी करना

यदि आप एक स्लाइस की सामग्री को शुरू में खाली स्लाइस में कॉपी करना चाहते हैं, तो इसे पूरा करने के लिए निम्नलिखित कदम उठाए जा सकते हैं-

1. स्रोत टुकड़ा बनाएँ:

var sourceSlice []interface{} = []interface{}{"Hello",5.10,"World",true}

2. गंतव्य स्लाइस बनाएं, इसके साथ:

• लंबाई = sourceSlice की लंबाई

var destinationSlice []interface{} = make([]interface{},len(sourceSlice))

3. अब गंतव्य स्लाइस के अंतर्निहित सरणी स्रोत स्लाइस के सभी तत्वों को समायोजित करने के लिए काफी बड़ा है, हम बिलिन copy का उपयोग करके तत्वों को कॉपी करने के लिए आगे बढ़ सकते हैं:

copy(destinationSlice,sourceSlice)

स्लाइस बनाना

स्लाइस विशिष्ट तरीके से जाने वाले प्रोग्रामर डेटा की सूची स्टोर करते हैं।

स्लाइस चर घोषित करने के लिए []Type सिंटैक्स का उपयोग करें।

var a []int

एक पंक्ति में एक स्लाइस वेरिएबल को घोषित करने और शुरू करने के लिए []Type{values} सिंटैक्स का उपयोग करें।

var a []int = []int{3, 1, 4, 1, 5, 9}

स्लाइस को इनिशियलाइज़ करने का दूसरा तरीका है make फंक्शन। इसके तीन तर्क हैं: स्लाइस का Type (या नक्शा ), length और capacity ।

a := make([]int, 0, 5)

आप append का उपयोग करके अपने नए स्लाइस में तत्वों को जोड़ सकते हैं।

a = append(a, 5)

len का उपयोग करके अपने स्लाइस में तत्वों की संख्या की जांच करें।

length := len(a)

cap का उपयोग करके अपने स्लाइस की क्षमता की जांच करें। क्षमता वर्तमान में स्लाइस के लिए स्मृति में रहने के लिए आवंटित तत्वों की संख्या है। आप हमेशा क्षमता पर एक स्लाइस के लिए अपील कर सकते हैं क्योंकि गो स्वचालित रूप से आपके लिए एक बड़ा स्लाइस बनाएगा।

capacity := cap(a)

आप विशिष्ट अनुक्रमण सिंटैक्स का उपयोग करके एक स्लाइस में तत्वों का उपयोग कर सकते हैं।

a[0]  // Gets the first member of `a`

आप range साथ स्लाइस पर लूप के for भी उपयोग कर सकते हैं। पहला चर निर्दिष्ट सरणी में सूचकांक है, और दूसरा चर सूचकांक के लिए मूल्य है।

for index, value := range a {
    fmt.Println("Index: " + index + " Value: " + value)  // Prints "Index: 0 Value: 5" (and continues until end of slice)
}

खेल का मैदान जाओ

एक स्लाइस छानना

नया अंतर्निहित सरणी आवंटित किए बिना एक स्लाइस को फ़िल्टर करने के लिए:

// Our base slice
slice := []int{ 1, 2, 3, 4 }
// Create a zero-length slice with the same underlying array
tmp := slice[:0]

for _, v := range slice {
  if v % 2 == 0 {
    // Append desired values to slice
    tmp = append(tmp, v)
  }
}

// (Optional) Reassign the slice
slice = tmp // [2, 4]

स्लाइस का शून्य मूल्य

स्लाइस का शून्य मान nil , जिसकी लंबाई और क्षमता 0 । एक nil स्लाइस में कोई अंतर्निहित सरणी नहीं है। लेकिन वहाँ भी लंबाई और क्षमता के गैर शून्य स्लाइस हैं 0 , जैसे []int{} या make([]int, 5)[5:] ।

शून्य मान रखने वाले किसी भी प्रकार को nil स्लाइस में बदला जा सकता है:

s = []int(nil)

यह जांचने के लिए कि क्या एक टुकड़ा खाली है, उपयोग करें:

if len(s) == 0　{
    fmt.Ptintf("s is empty.")
}